Il s'agit d'un défi de chaînage de réponses dans lequel chaque réponse s'appuie sur la réponse précédente. Je recommande de trier le fil par "plus ancien" pour être sûr de l'ordre dans lequel les messages sont faits.

Remarque : le défi est devenu assez long et il est relativement difficile d'afficher de nouvelles réponses. En tant que tel, un forum de discussion est maintenant disponible pour ce défi. Si vous souhaitez obtenir des conseils sur une partie particulière d'une réponse potentielle, avez des idées de langues pouvant être ajoutées ou similaires. N'hésitez pas à venir si vous avez quelque chose à demander ou à dire!

La tâche

Le n e programme à soumettre doit fonctionner en n langues différentes; spécifiquement, toutes les langues ajoutées dans les programmes précédents à soumettre, plus une de plus. Le programme doit générer 1 lorsqu'il est exécuté dans la première langue utilisée dans les réponses à cette question, 2 lorsqu'il est exécuté dans la deuxième langue, etc. Par exemple, la première réponse pourrait imprimer 1 lorsqu'elle est exécutée en Python 3, et la deuxième réponse en sortie 1 lorsqu'elle est exécutée en Python 3 et 2 lorsqu'elle est exécutée en JavaScript. dans ce cas, la troisième réponse devrait générer 1 lorsqu'elle est exécutée en Python 3, 2 lorsqu'elle est exécutée en JavaScript et 3 lorsqu'elle est exécutée dans un autre langage.

Règles supplémentaires

• Votre programme doit être exécuté sans erreur ni panne. Les avertissements (et les autres sorties stderr) sont acceptables, mais le programme doit se terminer normalement (par exemple, en exécutant la fin du programme ou via une commande telle exitque l'exécution du programme se termine normalement).

• La sortie doit être uniquement l'entier, mais les retours à la ligne sont corrects. Les autres sorties inévitables de stdout sont également autorisées. Exemples: nom et version de l'interprète dans Befunge-93, espace après la chaîne imprimée dans Zephyr. Certaines langues proposent deux méthodes d’impression: avec et sans espace de fin; dans ce cas, la méthode sans espace de fin doit être utilisée.

• Chaque réponse ne doit pas dépasser 20% ou 20 octets (la valeur la plus grande étant la plus longue) par rapport à la réponse précédente. (Ceci afin d’empêcher l’utilisation de langages tels que Lenguage spamming et d’encourager au moins une petite partie de golf.)

• L'utilisation de différentes versions de la même langue est autorisée (bien que, de toute évidence, ils devront imprimer des numéros différents, vous devrez donc adapter une vérification de version au polyglot). Cependant, vous ne pouvez pas utiliser une fonctionnalité de langue qui renvoie le numéro de version de la langue. Il est évidemment impossible de répéter le même langage (car le programme devrait imprimer de façon déterministe l’un des deux nombres différents).
• Des astuces comme l'abus de commentaires excessif, bien qu'interdites dans certaines compétitions polyglottes, conviennent parfaitement.
• Vous n'êtes pas obligé d'utiliser les réponses précédentes pour vous aider à rédiger le vôtre (vous pouvez réécrire l'ensemble du programme si vous le souhaitez, à condition qu'il soit conforme aux spécifications); Cependant, il est permis de baser votre réponse principalement sur une réponse précédente et constitue probablement le moyen le plus simple de trouver une solution.
• Vous ne pouvez pas soumettre deux réponses à la suite. Laissez quelqu'un d'autre poster entre les deux. Cette règle s'applique jusqu'à ce que la condition de victoire soit remplie.
• Comme ce défi exige que les autres concurrents publient dans les mêmes langues que vous, vous ne pouvez utiliser des langues avec une implémentation gratuite (comme s'il s'agissait d'un concours de policiers et de voleurs ).
• Dans le cas où une langue a plus d'un interprète, vous pouvez choisir n'importe quel interprète pour une langue donnée, à condition que tous les programmes censés fonctionner avec succès dans cette langue le fassent également. (En d’autres termes, si un programme fonctionne avec plus d’un interprète, les futurs messages pourront choisir l’un ou l’autre de ces interprètes, plutôt qu’un message "verrouillant" un choix particulier d’interprète pour une langue).
• Ce défi utilise désormais les nouvelles règles PPCG relatives au choix de la langue : vous pouvez utiliser une langue ou un interprète de langue, même si celle-ci est plus récente que la question. Toutefois, vous ne pouvez pas utiliser un langage / interprète plus récent que la question suivante: a) la langue a été conçue dans un but de polyglotte ou b) la langue a été inspirée par cette question. (Les langages de programmation pratiques nouvellement conçus vont certainement très bien fonctionner, tout comme les esolangs indépendants, mais des choses comme A Pear Pear , inspiré de cette question, sont interdites.) Notez que cela ne change pas la validité des langages conçus pour polygloter qui sont plus âgés que cette question.
• Notez que la condition de victoire (voir ci-dessous) est conçue pour que rompre la chaîne (c'est-à-dire empêcher toute autre personne de répondre après vous via l'utilisation d'une langue difficile à polygloter avec d'autres langues) vous empêchera de gagner. Le but est de continuer aussi longtemps que possible et si vous voulez gagner, vous devrez respecter cela.

Format de réponse

Comme toutes les réponses dépendent les unes des autres, il sera utile d’avoir un format de réponse cohérent. Je vous recommande de formater votre réponse de la manière suivante (ceci est un exemple pour le deuxième maillon de la chaîne):

2. JavaScript, 40 octets

(program goes here)

Ce programme imprime 1 en Python 3 et 2 en JavaScript.

(si vous voulez expliquer le programme, les techniques de polyglotte, etc., placez-les ici)

Condition de victoire

Une fois qu'il n'y aura pas eu de nouvelle réponse pendant 14 jours, le gagnant sera celui qui aura posté la deuxième réponse la plus récente, c'est-à-dire le plus grand polyglotte dont il a été prouvé qu'il ne rompait pas la chaîne. L'extension de la chaîne par la suite est toujours la bienvenue!

Le gagnant est Chance , voir la réponse 194 (TemplAt) .

Liste de langue

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

Remarque: si vous voyez ceci en premier, vous voudrez peut-être trier par ordre le plus ancien.

17. Julia (128 octets)

#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

Il y a deux contrôleurs sur la dernière ligne, un avant le premier get un après le 2. Cela pourrait être joué plus au golf, mais V et Pyth n'ont pas été compliqués.

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 rétine, 9 en Perl, 10 en Befunge-93, 11 en Befunge -98, 12 dans la fission, 13 dans le rubis, 14 dans le Turtléd, 15 dans la botte de foin, 16 dans le pyth et 17 dans le Julia .

Conseils:

• Le début de la quatrième ligne est Python 2/3, Perl, Ruby. La fin est Julia, grâce aux #=commentaires multilignes (notez que Julia n’a pas and/or).
• V est <ESC>gg99ddi2<ESC>, ce qui est vraiment golfable mais V est agaçant à tester Essayez-le en ligne! puisque l'interprète est assez lent.
• Minkolang et Haystack tombent au premier abord v. Befunge-93 et -98 ne le font pas, et dépendent b.
• Retina compte le nombre d'espaces et de 1 dans la quatrième ligne et V se cache dans la configuration pour Retina (c'est-à-dire avant le backtick).
• Selon l'indice de @ ETHproduction, Japt utilise des backticks pour masquer la majorité du code d'une chaîne.
• La fission est R"12"*.
• SMBF a été joué <.en première ligne, plus la finale 6.

23. Hexagonie , 186 octets

Désolé si cela gâche les plans ...

#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

␛ est utilisé pour représenter un caractère ESC littéral.

Impressions:

23 en Hexagonie , 22 en charge partielle, 21 en Nim, 20 en Prélude, 19 à Reng (testable ici ), 18 à Cardinal, 17 à Julia, 16 à Pyth, 15 à Haystack, 14 à Turtlèd, 13 à Ruby, 12 à Fission, 11 dans Befunge-98, 10 dans Befunge-93, 9 dans Perl, 8 dans la rétine, 7 dans Japt , 6 dans SMBF, 5 dans Python 2, 4 dans> <>, 3 dans Minkolang, 2 dans Vim / V et 1 en Python 3.

Pour accéder aux langues non liées, cliquez sur le change languagebouton situé dans le coin supérieur droit du lien Hexagonie.

L'hexagone n'est pas lisible (du tout) dans ce format. Nous devons le regarder sous forme hexagonale.
Notez que les 2 caractères ESC ont été remplacés par ␛s pour que vous puissiez les voir - ils sont ignorés, il n'y en a donc pas d'autres dans le programme:

        # 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

Pour ceux qui ne connaissent pas Hexagony , il existe 6 adresses IP, qui commencent aux 6 coins. Seul 1 est actif à la fois et est activé à l'aide de #][. Le modèle de mémoire n'est pas si important pour ce programme, mais peut être nécessaire pour comprendre à l'avenir. Tout ce que vous devez savoir, c'est que 1 int est stocké dans un "bord de mémoire" (ME en abrégé) et '"}{modifie le ME actif.

\/|_>< sont des miroirs qui contrôlent le déroulement du programme.

Voilà comment cela fonctionne:

Première ligne exécutée:

#       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

Le bas (extrait renversé verticalement pour que vous puissiez lire de haut en bas):

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

Le bord droit:

        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 !

Le dernier bit de code pertinent:

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

Choses à noter:

• Hexagony supprime tous les s et `s avant de s’exécuter, ainsi toute modification de ceux-ci n’affectera pas Hexagony
• J'avais besoin de remplir le code pour qu'il soit interprété comme un hexagone de 9 longueurs au lieu d'un 8ème - soyez prudent en jouant au-dessous de 169 ou au-dessus de 217 caractères pertinents
• Pour cette raison, le ~~~et les 2 0s à la fin peuvent être modifiés sans endommager le code
• Le =""just éloigne le ME du précédent afin qu'un nouveau ME puisse être modifié. Ils peuvent être remplacés par d'autres personnages qui font la même chose sans nuire au programme hexagone ( 's, par exemple)
• Techniquement, cela n’est pas conforme aux spécifications de Befunge 93, car il limite la boîte englobante du code à 80 par 25 caractères. Cependant, la plupart des interptrètres ignorent cette spécification (comme TIO), donc personnellement, je ne pense pas que ce soit un gros problème. Si vous le faites, n'hésitez pas à laisser un commentaire. (Si assez veulent vraiment que je change, alors je vais essayer)
• J'espère que ce n'est pas trop difficile maintenant.

50. bash, 1024 octets

#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

Voulez-vous en savoir plus? Essayez le chat polygot !

Essayez-les en ligne!

Comme d'habitude, j'ai remplacé les tabulations littérales par ␉et les caractères ESC littéraux par ␛, en raison des limitations de Stack Exchange. Vous pouvez obtenir une version facilement copiable du programme dans la case "entrée" du lien TIO ci-dessus.

Fatigué

Ce programme imprime 50 en bash, 49 en octave, 48 en Deadfish ~, 47 en Lys, 46 en Cubix, 45 en PicoLisp, 44 en naduck, 43 en réticulaire, 42 en diabolique, 41 en cervelle ***, 40 en Minimal. -2D, 39 en CoffeeScript, 38 en C, 37 en C ++, 36 en Labyrinth, 35 en INTERCAL, 34 en Rail, 33 en Incident, 32 en Whirl, 31 en SNUSP modulaire,30 dans les espaces blancs, 29 dans les déclencheurs, 28 dans Brain-Flak, 27 dans les Perl, 26 dans 05AB1E, 25 dans Pip, 24 dans Thutu, 23 dans Hexagony, 22 dans Sous-charge, 21 dans Nim, 20 dans Prelude, 19 dans Reng , 18 à Cardinal, 17 à Julia, 16 à Pyth, 15 à Haystack, 14 à Turtlèd, 13 à Ruby, 12 à Fission, 11 à Befunge-98, 10 à 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 et 1 en Python 3.

Vérification

La plupart des langues sont testées par le pilote de test ci-dessus. Les quatre coupables habituels doivent être testés séparément:

• L’incident a été testé avec son interprète officiel, hors ligne;

• Deadfish ~ a également été testé avec son interprète officiel, hors ligne;

• Le SNUSP modulaire a été testé en ligne ici ;

• Reng a été testé en ligne ici .

Explication

Je cherchais diverses pistes à ajouter pour les langues. Une possibilité consistait à trouver un langage avec des #commentaires de ligne pouvant être ajouté de manière plausible à la ligne "langage de script" (qui gère Perl, Python 2 et 3 et Ruby). Il m'a fallu un certain temps pour réfléchir à un langage approprié qui pourrait être compatible avec la syntaxe avec ceux qui existaient déjà.

Il se trouve que la réponse me regardait dans les yeux depuis des lustres. Si vous cliquez sur le lien TIO ci-dessus, le pilote de test polyglot, écrit en bash, s'ouvrira. Donc pendant tout ce temps, j'avais un onglet qui disait "Bash - TIO Nexus". Vous auriez pensé que ce serait un indice, mais apparemment, je l'ai raté. En prime, bash est également un langage de script. Le terme "ligne de langage de script" est toujours approprié.

Le programme bash commence au même endroit que les autres langages de script. Cependant, il existe un moyen assez simple de les séparer; dans les chaînes entre guillemets simples, \est un caractère d'échappement dans la plupart des langues, mais pas en bash. Nous pouvons donc masquer le code bash des autres langages via '\'…';, ce qui est une instruction dégénérée (sans effet) en Perl, Python et Ruby, mais exécutée en bash. echo 50;exitest un moyen assez simple de mettre fin au programme bash. Enfin presque.

Le plus gros problème ici est que bash, lorsqu’il sera lancé exit, continuera l’analyse jusqu’à la fin de la ligne courante (même s’il n’exécute pas le code en question), nous devons donc nous assurer qu’il n’ya pas d’erreur de syntaxe dans le reste de la ligne. la ligne. Nous avons 'juste après exit;cela n'est pas (et ne peut pas être) immédiatement apparié. Plus tard sur la ligne, '…'est utilisé pour cacher du code Brain-Flak aux langages de script, mais cela le dévoilerait de bash. Par conséquent, nous devons modifier le type de littéral de chaîne utilisé pour masquer le code, en passant de chaînes entre guillemets à des guillemets. or"'"fait le tour sans déranger Perl, Python ou Ruby (comme l'argument de la main gauche est la vérité dans tous les cas).

Nous avons maintenant une citation double inégalée qui s'étend sur une future ligne. Il était assez difficile de le fermer sans déranger au moins une autre langue; ce que nous faisons en réalité est de changer la façon dont nous cachons le code de bash de citation double en une citation unique sans correspondance dans un commentaire Python / Ruby sur la ligne suivante, puis de fermer la citation simple à la fin de la ligne.

Pyth et 05AB1E

La confusion avec les guillemets doubles perturbe également les langues qui utilisaient des chaînes entre guillemets pour masquer le code, Pyth et 05AB1E. Le principal truc que nous utilisons ici est de nous assurer que chaque citation double que nous ajoutons aura bientôt une autre citation double afin d’exposer le moins de code possible. (Cela explique le double guillemet supplémentaire sur la __DATA__ligne, ce qui n'est pas nécessaire pour bash.) Pyth utilise \comme caractère d'échappement; le résultat principal est que cela limitait les possibilités de déconner avec des chaînes dans les langages de script, me forçant à utiliser la méthode plutôt compliquée ci-dessus (car je ne pouvais pas facilement utiliser la différence de \comportement entre bash et tout le reste autre). Dans 05AB1E, 'agit en tant que caractère d'évasion à l' extérieurcordes, et l'avoir échapper à la direction "ne ferait pas. J'ai donc fini par avoir besoin de placer un caractère de remplissage inutile (comme d'habitude x; cela rend les choses plus faciles à lire!) À l'intérieur des "'"constructions utilisées pour passer d'un style de citation à l'autre bash.

Prélude

De loin la langue la plus difficile à résoudre ici. Le problème est que la ligne de script, avec toutes ses parenthèses, a été déplacée latéralement et que le flux de contrôle Prelude (qui tient beaucoup à la façon dont les parenthèses sont alignées verticalement) a été complètement détruit. Je devais donc essayer de reconstruire quelque chose qui fonctionne.

Pire encore, la première ligne actuelle (que je ne voulais vraiment pas réécrire) impose une limite stricte à l'endroit où les parenthèses peuvent apparaître. Il commence avec un chiffre différent de zéro (deux d'entre eux, en fait!), Et est bientôt suivi d'une parenthèse ouvrante. C'est une boucle dans Prelude et les boucles au début du flux de contrôle dans Prelude causent un certain nombre de problèmes différents (principalement parce qu'ils entraînent plus de code à s'exécuter que moins). En tant que tel, j’ai eu grand besoin d’ouvrir une boucle à 0 itération sur une autre ligne pour passer ce code. La mainligne pour le programme C convient parfaitement, mais nous devons faire très attention à l’emplacement de la parenthèse de fermeture correspondante; trop loin à droite et le support inégalé sur le#R+ligne causera des problèmes, trop à gauche et il ne commentera pas assez de code. (N'oubliez pas qu'une parenthèse ouvrante sur une ligne peut correspondre à une parenthèse fermante ou à une ligne différente.)

Une fois cela fait, nous avons juste assez d’espace pour insérer une parenthèse dans la ligne Incident, et nous avons enfin dépassé les quelques premiers caractères du programme. Cependant, la différence entre les placements entre parenthèses finit par signifier que certains codes Incident / Whirl s'exécutent réellement dans Prelude, ce qui altère la pile. Au lieu d’essayer d’empêcher cela, j’ai déplacé certains zéros de Whirl plus à droite, ce qui leur a permis de nous proposer à nouveau un programme Prelude opérationnel.

Un autre petit changement était sur la première ligne du programme; la parenthèse finale de la ligne était dans une position très difficile à éviter. J'ai ajouté un extra cjuste après le code Pyth pour le décaler à droite. (De nombreuses langues analysent ce point du programme, il a donc fallu un nombre surprenant d'essais et d'erreurs pour trouver un caractère de remplissage qui ne romprait pas au moins une langue!)

Incident

Prelude était déjà assez difficile en soi, mais faire travailler Prelude et Incident en même temps était cauchemardesque. Prelude a imposé de nombreuses contraintes au code, ce qui m'a empêché de déplacer librement les éléments et a ainsi rendu plus difficile la construction accidentelle de jetons. Par exemple, Prelude n’a besoin que d’être 0déplacé vers la droite, mais c’est 00devenu un jeton défaillant, cassant certains des jetons que nous souhaitions dans le cadre du programme Incident (parce que si deux jetons se chevauchent, ils sont tous deux rejetés et le 00chevauchait un jeton que nous voulions en plus du chevauchement lui-même). J'ai dû sortir tous les deux pour faire une quatrième copie et éviter qu'elle ne soit même considérée comme un jeton.

Plus subtiles sont les jetons ;'et ␠␠(c'est-à-dire deux espaces). Le problème est que ces deux éléments apparaissent avant le kGqui est utilisé pour sauter au début du programme, et vont donc interrompre le flux de contrôle d'Incident (en plus de casser le point central du programme).

Supprimer une copie de ␠␠en la cassant ne semble pas viable. Le supprimer par chevauchement serait peut-être possible ( ␠=un chevauchement potentiel prometteur), mais il est certainement moins verbeux d'ajouter simplement une quatrième copie, ce que j'ai fait ici.

En attendant, nous pouvons utiliser une astuce différente pour ;'. Je ne voulais pas essayer de le décomposer, car il est utilisé dans des situations relativement sensibles à l'espacement. Cependant, ce n’est pas si près du début du programme (bien qu’il apparaisse sur la première ligne), il est donc plausible que nous puissions le survoler (le faisant ainsi ne pas affecter le flux de contrôle) au lieu de le devoir de ne pas exister. J'ai cherché un jeton approprié à utiliser pour le saut, qui ne ferait rien foirer dans les autres langues. /vapparaît un peu plus tôt sur la première ligne et ne casse rien, et c’est ce que j’ai utilisé.

50 langues dans 1 Kib de code

@MistahFiggins a souligné que ma soumission de 1025 octets serait bien plus ordonnée si elle était de 1024 octets (d'autant plus que la cinquantième langue est une étape importante en soi). Cela nécessitait de trouver un octet d'économies quelque part. Dans ce cas, j’ai économisé trois octets dans Deadfish ~, au prix de deux octets supplémentaires utilisés pour aligner correctement les jetons Incident, ramenant ainsi le programme à 1024 octets exactement.

Auparavant, la formule utilisée par le code Deadfish ~ était (2² + 2) ² + 10 × 1 + 2 = 48. La nouvelle formule est la suivante (3²-2) ²-1, produisant également 48. Étonnamment, ce n’est pas cela. beaucoup plus court à écrire dans Deadfish ~, bien qu’il soit considérablement plus simple.

Cela nous donne également un score VIP de 0,008192. Il s’agit non seulement d’un nouveau record, mais aussi d’un nombre bien arrondi (ce qui est évidemment une conséquence de la présence de chiffres arrondis dans la formule).

37. C ++ (gcc), 776 octets

#  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

␉est un onglet littéral, ␛un caractère ESC littéral; Stack Exchange modifierait le programme autrement. Je vous recommande de copier le programme à partir de la zone "entrée" du lien TIO ci-dessous, si vous souhaitez y travailler.

Essayez-les en ligne!

Fatigué

Ce programme imprime 37 en C ++, 36 en Labyrinth, 35 en INTERCAL, 34 en Rail, 33 en Incident, 32 en Whirl, 31 en SNUSP modulaire, 30 en Whitespace, 29 en Trigger, 28 en Brain-Flak, 27 en Perl 6 , 26 à 05AB1E, 25 à Pip, 24 à Thutu, 23 à Hexagony, 22 à Underload, 21 à Nim, 20 à Prelude, 19 à Reng, 18 à 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 dans SMBF, 5 dans Python 2, 4 in> <>, 3 dans Minkolang, 2 dans V / Vim et 1 dans Python 3.

Vérification

La plupart des langues sont testées par le pilote de test illustré ci-dessus. Vous pouvez tester Reng ici et SNUSP modulaire ici ; ils produisent respectivement 19 et 31, selon les besoins.

J'ai ajouté un autre format à la sortie du pilote de test qui échappe aux guillemets et effectue des remplacements de saut de ligne. C’est pour que je puisse alimenter le programme en une seule chaîne (gcc) que j’ai enroulé autour de la fonction créée par @feersum ici . J'espère que d'autres pourront s'en servir tels quels.

Voici le programme de jeton d'incident . Idéalement, j'aimerais supprimer les jetons, car ils sont un peu difficiles à lire, indiquent le jeton "centre" et l'incluent dans le pilote de test. Mais je ne sais pas vraiment comment faire autre chose que de faire en sorte que divers programmes affichent des entiers séquentiels, c'est donc ce que j'ai eu.

J'ai tenté de résoudre les problèmes évidents liés aux incidents, comme les jetons après le début et la fin des jetons de saut et tout ce qui vous paraissait étranger, mais je n'ai pas équilibré les jetons à placer 0oau centre. Je ne suis pas vraiment sûr de ce que la logique est exactement pour déterminer le centre. J'espère que @ ais523 aidera là-bas. Cette chaîne près de la fin 7LEintndus({})!<>+serait un jeton, sinon pour cette 4ème inclusion dans le code. Ceux-ci peuvent tous être supprimés (et remplacés par un .pour l'alignement Hexagony) afin d'ajuster le jeton central.

Je vais mettre à jour ce message de temps en temps au cours des prochains jours pour parcourir le code (en supposant qu'un incident puisse être vérifié / résolu sans dépasser le nombre d'octets). Mais il est très tard maintenant, et je voulais surtout que tout ça se passe avant de devoir résoudre un autre problème semblable à Labyrinth. : P

Explication

Comment fonctionne le code C ++.

Je pense que la plupart des gens connaissent suffisamment le C ++, je ne vais donc pas entrer dans les détails. Les commentaires de bloc se présentent sous la forme de /* comment */. Les commentaires de ligne se présentent sous la forme de //comment. Le code utilisé par C ++ pour produire la réponse est int main() {std::cout<<37;}. Et la bibliothèque utilisée pour l'interface avec STDOUT est référencée par cette instruction #include<iostream>.

/ * Commentaires abus * /

Pour moi, l'histoire du C ++ remonte à ma réponse Brain-Flak.

Après avoir finalement trouvé le numéro 28, je me suis mis à étudier d'autres polyglottes postés dans PPCG et tout ce que j'ai étudié m'a amené à quelques réponses faciles (la plupart d'entre elles sont encore disponibles pour être trouvées si quelqu'un d'autre est si enclin à le faire). Mais plus important encore, je suis parvenu à une conclusion sur les polyglottes en général: les grands polyglottes ont tendance à tomber dans l'une des deux grandes catégories suivantes: #abus de /*commentaires ou abus de commentaires.

Ce n'est en aucun cas un fait ou une restriction, mais un cadre mental personnel qui a guidé mes prochaines réponses.

À partir de là, je pensais que si cela devait devenir le plus grand polyglotte du monde, comme je le suppose actuellement, ce serait mieux s'il pouvait exploiter l'abus de commentaires des deux familles de commentaires. Je me suis donc efforcé de trouver un moyen d’incorporer un /*langage de commentaires et d’ aller de l’avant vers la famille C du fait d’une familiarité personnelle.

Test initial C ++

Au début, je pensais utiliser C # principalement à cause de ma familiarité et le premier obstacle à surmonter était de placer le polyglotte dans un état où il pouvait accepter une ligne qui ne débutait pas #sans être traité comme un code par les langages de script. . La réponse de Rail, ainsi que plusieurs réponses de gonflage d’octets menant à celle-ci, ont résolu ce problème.

Vient ensuite le problème de la création du premier /*bloc de commentaires. Je savais que la ligne devrait commencer par une ligne #pour rester invisible pour Perl, Ruby et Python, mais tout ce qui arrivait avant /*serait lu par C #. J'ai d'abord essayé une #regionbalise C # , mais celle-ci s'est avérée trop striée pour les langages 2D. Entrez C ++.

C ++ a plusieurs directives de préprocesseur qui commencent toutes par #, ce qui donne beaucoup d'options pour les langages 2D à parcourir. Mais il s'est avéré que tous étaient incompatibles avec au moins un langage et, étant dans un espace de code exposé C ++, j'avais des solutions de contournement limitées. Par frustration et désespoir, je suis tombé sur le fait que C ++ n'accepterait simplement qu'un seul #avant le bloc de commentaires. Ok, peu importe, c'est réalisable. J'ai donc avancé avec la présomption que cela #/*pourrait fonctionner comme les trois premiers caractères du polyglotte.

Le deuxième élément de la vérification de base consistait à vérifier que la déclaration imprimée pouvait vivre avec les autres codes. D'après la réponse de Brain-Flak, je savais que Japt n'aimait pas les non-échappés {et que C ++ avait besoin de le dire int main() {std::cout<<37;}, ce dernier n'autorisant pas le caractère d'échappement de Japt au milieu de son code. Cette fois, j'ai eu la chance de constater que si je me retirais de la chaîne littérale de Japt uniquement pour cette déclaration, Japt produirait toujours avec le même résultat.

Pendant ce temps, Brain-Flak n'aimait pas ça non {}plus, mais j'ai de nouveau eu la chance de constater que C ++ acceptait les expressions #entre int main()et {std::cout<<37;}, ce qui permettait à l'accolade d'être commentée à partir du point de vue de Brain-Flak.

Ainsi, les principaux problèmes de C ++ étant théoriquement résolus, j'ai entamé le processus ardu de résolution de toutes les erreurs que j'avais introduites.

Paysage 2D

La partie la plus difficile de cette réponse était de loin la reconfiguration des deux premières lignes du polyglotte. Et le problème le plus important était le *. Un sous-chargement ne permettra pas un *avant un (. Il considère cela comme une opération mathématique sur une pile vide, ce qui, à son avis, est une erreur. Donc, le polyglotte nécessitait un (avant le /*mais C ++ ne pouvait pas permettre cela. La solution a donc été de faire un commentaire de ligne C ++ //sur la première ligne pour masquer un (, puis de démarrer la deuxième ligne avec un #/*.

Ensuite, Befunge n’a pas vraiment aimé l’idée d’un /sans que quelque chose soit divisé, mais après avoir étudié la réponse existante de Begunge, 16/"<"6/b.q@j’ai trébuché sur l’idée d’un chiffre et d’une ficelle écrasée //. Cela a fonctionné et je ne sais pas pourquoi C ++ est d'accord avec cela, mais il accepte en # 1"16" 2tant que déclaration d'ouverture. Je ne vais pas le remettre en question, mais je sais que les espaces sont nécessaires pour que cela fonctionne.

Première ligne

Japt s'est avéré être plutôt sensible à l'espace et ne voulait pas vraiment entrer dans sa chaîne basée sur le backtick sur la ligne du dessus, aussi le backtick de Pip a été déplacé vers la deuxième ligne, forçant beaucoup de gymnastique linguistique sur la ligne 1.

• Pip n'a pas aimé la plupart de la ligne 1. Un deuxième espace a donc été placé après le premier #pour indiquer un commentaire.
• Le (for Underload devait être échappé de Japt avec un précédent \.
• #est un terminateur de saut dans Turtlèd, il était donc nécessaire, mais Pyth considère qu’il s’agit d’une boucle de fin d’erreur; Pyth avait donc besoin d’une division par null / après le#
• Je ne sais plus ce que @la première ligne fait, mais Pyth et Japt semblent aimer sa présence mieux qu’autrement, bien qu’il ne s’agisse @pas d’un caractère significatif, selon la documentation de Pyth.
• Et il semble que le premier ;puisse être supprimé à ce stade sans conséquence, aussi je ne suis pas sûr de ce qui a été résolu là-bas, bien que je soupçonne que c'était lié à Pyth. Mais il semble que les solutions futures peuvent sauver un octet en l'omettant.
• <> <et Turtlèd fonctionnent fondamentalement de la même manière qu’auparavant, avec <> <une réflexion sur le premier #et un retour à la fin de la première ligne. Et Turtlèd saute avec #comme je l’ai mentionné et termine avec la "14"corde qu’elle imprime.

Routage 2D

Ces problèmes étant résolus, la phase suivante consistait à acheminer les langages 2D. Auparavant, le vBefunges avait ignoré l'initiale #, mais avait envoyé Haystack et Minkolang. Désormais, l’espace initial tente d’envoyer Minkolang le long de la 3ème dimension, que sa documentation appelle la dimension temporelle.

La 3ème dimension de Minolang: je pense que c’est un malentendu d’appeler cela une dimension temporelle, cela me semble vraiment plus spatial que temporel. Je ne l'ai pas vraiment compris avant d'avoir trouvé ce lien qui illustre le concept et qui ressemble davantage aux multiples couches d'un échiquier 3D. Je pense que c'est ainsi que fonctionnent les langages 3D. Mais comme c'était un nouveau concept pour moi, j'ai pensé jeter cette information à d'autres.

Ainsi , plusieurs couches de Minkolang sont délimitées par des lignes se terminant par $$$que je jetais sur la fin du code ferroviaire ici: #-3o4o#$$$. Maintenant, Minkolang frappe l'espace et tombe d'abord >dans <>3N.<> ␉//et passe à droite sortie 3. #>ne pouvaient pas être autorisés à démarrer cette ligne parce qu'il tenterait de mettre fin à un bloc de commentaire Perl6, donc <est utilisé au lieu de l' #équilibre pour SMBF et cerveau -Flak. Cependant, il s'agit d'une procédure d'échange d'empilement Brain-Flak. Par conséquent, un second ensemble <>est utilisé après Minkolang Terminates afin de revenir à la réponse correcte de Brain-Flak.

De même, Labrynth se heurte à l’espace mais provoque la descente de Labrynth dans la colonne 1. Il redescend ensuite sur la ligne 2 où il se dirige vers 3un autre mur, le faisant se tourner à nouveau vers le sud et touchant un point qui fait apparaître ;le 3 . Ensuite, le programme continue à droite, où 36 est stocké et imprimé, avant de trouver une @sortie. Ce chemin est plus long que nécessaire, mais j’ai trouvé que Prelude générerait un octet nul avant sa sortie normale si la valeur !était plus à gauche qu’elle est maintenant, quelle que soit la ligne sur laquelle elle apparaît. J'ai donc rendu les choses plus correctes, car j'avais l'espace nécessaire pour le faire.

Ensuite, le routage de Haystack a été modifié car /il vient maintenant avant la vligne 1 et reflète son chemin comme Reng. Heureusement, Reng cohabite plutôt pacifiquement. Le seul problème était que l’aiguille de Haystack |était un réflecteur dans Reng, aussi un Reng utilise-t-il un Befunge comme jump ( #) sur l’aiguille pour conclure correctement Reng.

Les béfunges continuent le long de la ligne 1 jusqu’à la vpuis se dirigent vers le bas puis vers la droite sur la deuxième ligne pour conclure avec le même code que celui utilisé auparavant. Mon sentiment est que cette pièce peut être gâchée un peu maintenant que moins de langues tentent de parcourir le code de manière significative, mais je n'avais plus besoin de murs pour me cogner la tête, je l'ai donc laissée telle quelle.

Enfin, le point de départ de Cardinal est %qu'il n'avait pas particulièrement besoin d'être regroupé dans les deux lignes du haut déjà très denses. Alors je l'ai déplacé à la chaîne de Python. Ses multiples chemins de code sont également maintenant délimités par xs, ce qui met fin au mouvement de son pointeur.

Ligne 2 et 3

Le seul changement significatif ici est que tous ont :été golfés pour une raison ou une autre. Peut-être que les (besoins de Prelude ou ce sont peut-être de simples problèmes de comptage d’octets - probablement les deux. L'autre chose est que le code de saut de ce déclencheur a été déplacé en arrière et renommé auaaZ. J'avais un espace à remplir pour rencontrer le chemin de code de Befunge et cela semblait être le meilleur. Ce qui <suit est également destiné à équilibrer le suivi de SMBF >. Enfin, les seuls ”près de la fin de la deuxième ligne doivent conserver la chaîne de caractères de 05AB1E. De plus, la yyligne 3 ne contient que des caractères de remplissage pour Labyrinth.

Les gros Esolangs à cordes

Les deux premières lignes étant résolues, il était temps de creuser dans les esolangs à analyse plus complète, et Pip s'est avéré avoir un problème. Si vous vous en souvenez bien, nous avons {std::cout<<37;}résolu le problème des accolades en abandonnant la chaîne Japt pour permettre à Japt de le traiter comme du code. Eh bien, Pip utilise la même syntaxe de chaîne et n'aime pas cette ligne comme code et Pip a des options de déclaration de chaîne très similaires à celles de Japt. Les deux utilisent un simple 'pour déclarer une chaîne de caractères unique, utilisent la même déclaration d'échappement \et acceptent "comme identificateurs de chaîne. Il était donc difficile de faire croire à Pip que c'était une chaîne sans faire croire à Japt la même chose.

Il s'est avéré que Japt avait une différence exploitable: #prendre la valeur ascii du caractère suivant. Donc, #"`mettra fin à la chaîne Japt / pip, puis dites à Japt de prendre la valeur asci de ", tout en demandant à Pip de commencer une nouvelle chaîne. L' "aurait probablement pu être un backtick à la place, et aurait probablement été mieux, mais ma ligne de pensée était d'utiliser un identificateur de chaîne différent à l'intérieur comme un autre point de manipulation de chaînes. Voici donc un autre endroit où vous pourriez économiser quelques octets plus tard.

Ensuite, je devais initialiser la chaîne Japt après les accolades tout en permettant à Pip de rester dans une chaîne. J'ai fait cela avec '"`une citation simple, une citation double et un backtick. Pour Japt, le 'n'est pas dans une chaîne et est donc un indicateur pour prendre le caractère suivant comme une chaîne de caractères unique. Pip voit le 'comme faisant partie de la chaîne et termine sa chaîne par le ". Et enfin, `indique à Pip et à Japt qu’une autre chaîne commence, qui se poursuit tout au long du polyglotte jusqu’à la dernière ligne où les deux langues s’achèvent joyeusement.

Maintenant, Japt et Pip travaillaient tous les deux à ce stade, mais 05AB1E échouait à cause de l'utilisation d' "une erreur provoquant une exposition au code. Heureusement, celui-ci a été assez facile à résoudre en ajoutant un autre ensemble ", en laissant l'ensemble des manipulations de cordes "`#"\\'*/{std::cout<<37;}/*'"`".

Enfin, avec la ligne qui ressemble maintenant à ceci, int main() #/*"`#"\'*/{std::cout<<37;}/*'"`"Underload avait un problème. Les consécutives *étaient une autre erreur de syntaxe, alors j’ai jeté un ()au milieu de celui *-ci pour l’apaiser.

Les Esolangs Fragiles

Le grand obstacle était maintenant le White Space. Je n’entrerai pas dans les détails, car la plupart de la solution Whitespace est intégrée aux explications déjà données, et j’ai simplement passé sous silence les cas où l’espace a forcé quelques décisions. Je te regarde Labyrinth. Le gros changement cependant, est que le code à utiliser pour afficher la réponse de Whitespace se trouve sur la ligne 2-4 au lieu de 1-3. Cela est dû en grande partie à l'exposition au code de Japt à la ligne 1.

Thutu avait à l' origine des problèmes avec ce qui avait été cette ligne: int main() #/*()"`#"\'*/{std::cout<<37;}/*'"`". Alors, j’ai jeté un saut de ligne juste avant le premier #pour masquer tous les problèmes derrière un indicateur de commentaire, puis j’ai spammé un tas de messages de fin /partout où le code était exposé.

À ce stade, j'ai aligné Hexagony et trouvé un nouveau problème. Le code au tout début, qui a commencé sa vie en tant que # 1"16" 1fait, +en /+23!@n'est plus vide. Donc, je viens de retirer l’ +est et je le trouve maintenant à la sortie 123. C’est assez facile à corriger en modifiant le gambit # 1"16" 2initial en golfant la pièce Hexagony /3!@.

Whirl a eu quelques changements, mais il s’agissait surtout de s’assurer que le nombre correct de 1 en tête apparaissait avant la ligne Whirl-Incident. Incident avait un jeton qui était particulièrement difficile. J'ai eu exactement 3 copies de /*et */.

Au départ, je voulais simplement insérer *//*n'importe quelle ancienne place dans le code pour créer une 4e copie de chaque copie, mais Underload a encore une fois vu la suite *, ce qui était tout à fait normal . En fin de compte, j’ai inséré un point /au bout de cette ligne int main() /*pour le terminer /*/, pensant que les jetons se chevaucheraient, mais j’ai réussi seulement à créer 4 copies de l’un des deux jetons. C'est vrai. C'est comme ça que ça marche. Oh bien, je vais juste lancer un semblable /dans la finale */pour faire un 4ème là-bas. Après cela, j'ai remplacé un groupe d'hexagones sans opération par une 4ème copie de plusieurs jetons d'incident dans cette chaîne sur la dernière ligne 7LEintndus({})!<>+.

Conclusion

Ok, c’est tous les détails que j’ai pour ce refactor massif. Je promets de ne pas avoir tant de choses à écrire à propos de la prochaine fois. En fait, je ne sais pas du tout si C ++ est un bon ou un mauvais choix pour ce polyglotte, mais je pense que cela ouvre certaines options. Espérons que cela mène à de bonnes choses.

Bonne codage.

3. Minkolang v0.15 (26 octets)

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

Ce programme imprime 1 en Python 3, 2 dans Vim et 3 dans Minkolang v0.15

J'espère ne pas gâcher les choses en introduisant un langage 2d

Essayez-le en ligne!

Explication

#                     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 ignore en quelque sorte Minkolang, donc c'est bien

Et il n'y avait vraiment pas de problème avec Python puisqu'il ignore les commentaires #

Prochain...

Pour la langue suivante, je suggère quelque chose comme> <> dans la mesure où il #agit comme un réflecteur (de sorte que la direction change à gauche et qu'elle se termine complètement dans la droite) afin que vous puissiez ajouter du code qui peut être ignoré par d'autres langues.

5. Python 2 (35 octets)

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

Ce programme imprime 1 en Python 3, 2 en Vim, 3 en Minkolang v0.15, 4 in> <> et 5 en Python 2.

Essayez-le en ligne bêta!

En Python 2, 1/2 est 0, ce qui est une valeur de fausseté, ce qui donne l'impression Python 5. En Python 3, 1/2 est égal à 0,5, ce qui est une valeur de vérité, ce qui fait que Python affiche 1.

4.> <> (29 octets)

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

Ce programme imprime 1 en Python 3, 2 en Vim, 3 en Minkolang v0.15 et 4 en> <>

Essayez-le en ligne!

Le code a couru

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

Encore un autre langage 2D.

N'a aucun effet sur Minkolang car il ajoute des caractères après le changement de direction, est ignoré par Vim pour une raison quelconque. #est un commentaire en Python donc pas de changement leur non plus.

28. Flak cérébrale , 280 octets

#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

␛ représente un caractère ESC littéral, comme d'habitude.

Ce programme imprime 28 en Brain-Flak , 27 en Perl 6 , 13 26 en 05AB1E , 25 en Pip , 24 en Thutu , 23 en Hexagonie , 22 en Sous - charge , 21 en Nim , 20 en Prelude , 19 en Reng (testé ici ), 18 à Cardinal , 17 à Julia , 16 à Pyth , 15 à Haystack , 14 à Turtlèd , 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 Vim / V , 1 en Python 3

Tout d'abord, je veux dire quel privilège de pouvoir contribuer à ce défi. Il n’ya que quelques semaines que j’ai entendu parler du code golf et je suis absolument devenu accro depuis. La première chose que j'ai faite quand j'ai trouvé ce défi était d'essayer de faire fonctionner le code tel quel dans différentes langues, juste pour voir si je pouvais trouver quelque chose avec lequel je pourrais travailler. C'était à l'époque où nous étions comme # 6. Honnêtement, je pensais que ce défi était dingue, mais nous y sommes (# 28 Wow!). Ce que j’ai trouvé à l’époque, c’est que Brain-Flak a donné la valeur 2. Je me suis donc mis à l’apprendre.

Brain-Flak s'est avéré être très bon pour ce genre de défi parce que c'est assez facile à apprendre et qu'il ignore pratiquement tous les personnages sauf (){}[]<>. #arrive également commenter quoi que ce soit après sur la même ligne, de sorte que la seule partie de la dernière soumission prise en compte pour Brain-Flak était celle print((eval("1\x2f2")and 9 or 13)-(0and 4)^1<<65>>62)qui était ensuite jumelée à ((())()<<>>). Le plan a donc été ajouté en ajoutant des parenthèses superflues à ce que je considère comme le code python.

J'ai modifié les bits de python pour les analyser dans Brain-Flak, ((() () ())()()<<()>>)ce qui équivaut à 2 piles, la première étant 5 et la seconde 3. Après cela, je quadrille le 5 avec ({({})({}[()])}{})et ajoute le résultat à 3 avec ({}{}). Cette quadrature et cette addition se déroulent dans une chaîne depuis une perspective Python. Je ne peux pas prétendre comprendre le raisonnement de Python ici, mais je suis assez convaincu que cette chaîne n'est pas autrement évaluée de manière significative par d'autres langages, à quelques exceptions près.

Il s'avère que Japt interprète les accolades d'une chaîne comme contenant du code, mais elles étaient assez faciles à échapper \avant chaque {dans cette chaîne. Mais cela a gonflé le nombre d'octets. C'est la vie.

Prelude était plutôt indulgent avec toutes mes parenthèses. Un commentaire précédent indiquait que Prelude aurait des correspondances avec des parenthèses alignées verticalement et qu'il m'arrivait d'en créer un. Sucré! Le (dans la ligne du haut aligné avec le et (9dans la grande ligne. J'ai donc dû ajouter un espace supplémentaire avant la (dans la ligne du haut. Mon hypothèse est que le double espace était un indicateur de commentaire pour quelque chose, donc ajouter un espace supplémentaire semblait trivial et cela a fonctionné. Je dois souligner que j'ai essayé d'ajouter des espaces supplémentaires à la (9)place, mais Cardinal n'a pas coopéré.

05AB1E n'a pas aimé ma première tentative d'encapsulation de la chaîne Python entre guillemets, mais tout le monde a paru disposé à utiliser des guillemets simples. Pas un gros problème là-bas.

Hexagony était la seule langue qui restait à ce stade, et j'étais évidemment bien au-delà du prochain seuil de taille d'hex, il était donc temps de se salir. La /^23!@est le code Hexagony et je suis très excité à ce sujet, car je pense que cela facilitera beaucoup les ajouts futurs. Ce petit morceau peut être déplacé n'importe où dans la chaîne python sans éclater de code. C'est la chaîne complète pour que nous soyons tous sur la même page '(\{(\{})(\{}\/^23!@[()])}\{})(\{}\{})'. Le /ici définit le chemin de Hexagony de SE -> NW à W-> E dans cette chaîne, avec laquelle nous avons beaucoup de marge de manœuvre. (Le précédent \est d'échapper/pour thutu BTW). Mon idée ici est que si vous apportez des modifications, il y a de fortes chances que vous finissiez par parcourir cette chaîne à un moment donné et que vous puissiez faire glisser le morceau Hexagony dans la chaîne pour capturer le chemin du code et l'envoyer à la bonne conclusion. Veillez simplement à ne pas vous placer entre Japt \et le {. Si vous rencontrez des problèmes, la partie @droite de la chaîne provient d'une autre solution Hexagony et peut être supprimée sans incidence sur les autres langues. Et bien sûr, si vous trouvez que le chemin du code de Hexagony va dans le sens opposé, vous pouvez bien sûr utiliser à la @!32^\place de /^23!@. En outre, vous remarquerez peut-être que ma solution a supprimé le===2du code pour garder les choses sous la limite d'octet. Quelqu'un a mentionné ici que c'était pour l'alignement de Hexagony et que je n'en avais plus besoin.

Enfin, voici un petit morceau de code trouvé lors de l’exploration de codegolf qui convertit une ligne de texte en hexagone lisible par Hexagony afin que vous puissiez déboguer. Je suis sûr que beaucoup de gens sont au courant de cela, mais je ne l'avais pas vu posté ici, donc ça pourrait aider quelqu'un d'autre aussi. Attention, vous devez modifier les entrées pour supprimer les backticks et les retours chariot, ainsi que permuter l'échappement littéral contre quelque chose qui prend beaucoup de place pour que le code puisse s'aligner dans un bel hexagone.

PS Pendant que j'écrivais ceci, j'ai réalisé que j'avais une erreur. J'avais cru effacer la mémoire de Hexagony ^, mais apparemment, je peux le remplacer par un non-op sans conséquence. Cela ^devrait probablement être un +si vous essayez de manipuler cette section. J'étais apparemment passé par là +avant cela, mais les futurs polyglotteurs n'auront peut-être pas cette chance.

Bonne chance!

38. C, 804 octets

#  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

␉est un onglet littéral, ␛un caractère ESC littéral; Stack Exchange modifierait le programme autrement. Je vous recommande de copier le programme à partir de la zone "entrée" du lien TIO ci-dessous, si vous souhaitez y travailler.

Essayez-les en ligne!

Fatigué

Ce programme imprime 38 en C, 37 en C ++, 36 en Labyrinth, 35 en INTERCAL, 34 en Rail, 33 en Incident, 32 en Whirl, 31 en SNUSP modulaire, 30 en Whitespace, 29 en Déclencheur, 28 en Brain-Flak, 27 en Perl 6, 26 en 05AB1E, 25 en Pip, 24 en Thutu, 23 en Hexagony, 22 en Sous-charge, 21 en Nim, 20 en Prélude, 19 à Reng, 18in Cardinal, 17 en Julia, 16 en Pyth, 15 en botte de foin, 14 en tourteau, 13 en rubis, 12 en fission, 11 en Befunge-98, 10 en béfunge-93, 9 en perl 5, 8 en rétine, 7 en Japt, 6 dans SMBF, 5 dans Python 2, 4 in> <>, 3 dans Minkolang, 2 dans V / Vim et 1 dans Python 3.

Vérification

La plupart des langues sont testées par le pilote de test illustré ci-dessus. Vous pouvez tester Reng ici et SNUSP modulaire ici ; ils produisent respectivement 19 et 31, selon les besoins.

Voici ma version légèrement modifiée du tokeniser Incident , conçu pour être un peu moins joué mais un peu plus utile.

Explication

J'ai toujours aimé faire de petites polyglottes mais jamais une aussi grosse que celle-ci; Je pensais que je devrais probablement essayer!

Après la merveilleuse réponse en C ++ de @ Chance, C semblait être le prochain choix logique et, compte tenu de la facilité relative avec laquelle il était ajouté, j'ai décidé de tenter le coup dès que j'en ai eu l'occasion!

J'ai utilisé une astuce très connue pour faire la différence entre C et C ++; la taille d'une constante de caractère est de 1 octet en C ++, mais la taille d'un int (il est garanti d'avoir au moins 16 bits) en C. Ce code doit être très portable (sauf peut-être pour les systèmes qui utilisent des octets avec suffisamment de bits pour tenir un int), sauf si J'ai commis une erreur stupide.

J’ai d’abord essayé de créer une liste printfavec tout ce qui était en ligne, mais les multiples crochets semblaient poser problème à Japt, aussi j’ai simplifié la ligne, ce qui a semblé résoudre le problème.

Ensuite, Cardinal n'a pas aimé, j'ai deviné à cause de l'impression %dans le printf, donc j'ai dû résoudre ce problème en passant à la manipulation de chaînes.

Ma tentative suivante, en essayant d’attribuer une chaîne puis de modifier le contingent du second octet sur le comportement du C, s’est avérée trop longue et aurait poussé Hexagony à la taille suivante; Je voulais éviter de le refaire en le gardant dans les caractères supplémentaires avec lesquels je devais jouer! J'avais besoin de chaque octet que je pouvais obtenir pour cela, alors j'ai implémenté les modifications d'économie d'octets suggérées par @Chance.

J'ai donc joué un peu dans ce code C et j'ai trouvé ce puts(sizeof'c'-1?"38":"37");qui fonctionnait presque, sauf que Underload était défectueux, probablement à cause de l'expression complexe entre crochets.

Même après avoir retiré le surplus >>qui était nécessaire pour correspondre à la<< à ceux de Perl6, je ne pouvais pas obtenir un moyen assez concis pour scinder la partie la plus complexe en une affectation de tableau de caractères. J'ai donc fini par envisager d'utiliser le préprocesseur à la place.

Après de nombreux essais et erreurs, j'ai trouvé une solution qui semblait plaire à Retina. Prelude, qui me causait des problèmes de temps en temps, a fini par se réparer avant que je ne commence à chercher pourquoi il se cassait (je suppose soit les crochets, soit le! que j'avais au ternaire à un moment donné, en regardant réponses précédentes).

Pendant tout ce temps, je corrigeais l'espace pour obtenir quelque chose que Whitespace aimerait; J'ai trouvé cela plutôt facile. En particulier, tab space space spacec’était une combinaison très utile (instruction d’ajouter les deux premiers éléments de la pile), car cela signifiait que je pouvais ajouter des espaces aux lignes sans autre espace sans que tout soit désynchronisé (je devine sa position dans le programme signifie qu’il n’est jamais réellement exécuté, je ne suis donc pas inquiet des sous-débits de pile ici).

J'ai maintenant testé Incident, et ça marche! Un grand merci à @Chance et @LliwTelracs, dont je viens de me rendre compte qu’il n’est PAS un nom gallois, de m’avoir aidé à y faire face. Voir cette coloration syntaxique . J'ai supprimé le ;jeton qui apparaissait avant le #yyjeton. J'ai fait cela en ajoutant simplement un extra ;après la getsdéclaration (ma tentative précédente consistait à remplacer s(qui apparaît maintenant beaucoup plus dans le programme C que dans la précédente) dans la chaîne "detokenising" avec un; , mais il s'est avéré que j'étais Hexagony (grâce @Chance) est donc un raccourci. Ainsi, après l'échec de la tentative d'ajout d'un caractère supplémentaire à cette dernière ligne, je l'ai simplement modifiée et ajouté le point-virgule supplémentaire ailleurs).

J'ai également légèrement modifié l'espace pour modifier d'autres jetons afin de tenter de centrer, de redéfinir le jeton Tab Linefeed (en déplaçant l'onglet au bout de la #includeligne au milieu, créant ainsi trois jetons), et de supprimer le jeton triple-espace en déplaçant un espace dans ladefine ligne.

Enfin, un jour après la soumission initiale, j'ai décidé d'aller au fond des alarmes effrayantes du préprocesseur que gcc produisait (et qui faisaient échouer Clang). J'ai déterminé que la première ligne fonctionnait bien parce que c'est la sortie du préprocesseur qui fournit des informations de débogage telles que les noms de fichiers d'origine et les numérotations de lignes. Ils n'aimaient pas le premier "2" sur la première ligne, parce que cela signifiait "revenir d'un fichier inclus dans le fichier donné", et c'est évidemment impossible étant donné qu'il n'y a pas eu de fichiers inclus. Après l'avoir changé en "1" (début d'en-tête normal), quelques langues ont été étranglées, je l'ai changé en "3" (en-tête de composant interne de départ), qui n'a cassé que Hexagony, puisqu'il s'appuyait maintenant sur le 2. Donc, au début du code Hexagony, j’ai ajouté un crochet ouvert(pour décrémenter le 3 en un 2, puis un crochet proche )après la fin (@ ) du code hexagone pour satisfaire les critères Retina, Prelude et Underload qui attendaient tous des crochets correspondants. Les nouveaux tests de Reng et de SNUSP modulaire n’ont généré aucun problème, et les jetons Incident semblaient bien, alors je l’avais corrigé! Je l'ai testé sur diverses architectures exotiques et il semble fonctionner. Je sais que ce n'est pas important pour un code de golf et que cela ne me dérange pas que les futurs émetteurs soient obligés de rompre avec cette mesure pour ne pas dépasser le nombre d'octets (ou si quelqu'un a déjà commencé à utiliser cette solution et ne veut pas changer le leur) trop, mais il ya une bonne raison pour cela: le compilateur Objective-C de TIO ne supporte que Clang, donc ce sera très utile si quelqu'un veut ajouter ça!

N'oubliez pas que je n'ai jamais utilisé la plupart de ces langues, j'espère que mon succès encouragera davantage de nouveaux arrivants à l'essayer!

65. ALGOL 68 (Génie) , 1634 octets

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

Note VIP ( Imprimante numérique polyvalente ): .005949 (pour améliorer, la prochaine entrée ne doit pas dépasser 1710 octets)

Essayez-le en ligne!

Fatigué

Ce programme imprime 65 en ALGOL 68, 64 en Agony, 63 en Brian & Chuck, 62 en Herbe, 61 en SILOS, 60 en Moorhens 2.0, 59 en Tcl, 58 en Ksh, 57 en Sage, 56 en courant continu, 55 en Cerveau -Flak Classic, 54 dans Zsh, 53 dans Shove, 52 dans COW, 51 dans Assembly, 50 dans Bash, 49 dans Octave, 48 dans Deadfish ~, 47 dans Lily, 46 dans Cubix, 45dans PicoLisp, 44 en alphuck, 43 en réticulaire, 42 en diabolique, 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 dans Incident, 32 dans Whirl, 31 dans SNUSP modulaire, 30 dans Whitespace, 29 dans Trigger, 28 dans Brain-Flak, 27 dans Perl 6, 26 dans 05AB1E, 25 dans Pip,24 à Thutu, 23 à Hexagony, 22 à Underload, 21 à Nim, 20 à Prelude, 19 à Reng, 18 à Cardinal, 17 à Julia, 16 à Pyth, 15 à Haystack, 14 à Turtlèd, 13 à Ruby, 12 à Fission, 11 dans Befunge-98, 10 dans Befunge-93, 9 dans Perl 5, 8 dans Retina, 7 dans Japt, 6 dans SMBF, 5 dans Python 2, 4 dans> <>, 3dans Minkolang, 2 dans V / Vim et 1 dans Python 3.

Vérification

La plupart des langues peuvent être testées avec le pilote de test ci-dessus, mais 6 langues doivent être testées localement.

• Reng peut être testé jusqu'à la sortie 19 ici .

• Le SNUSP modulaire peut être testé pour produire la sortie 31 ici .

• L'incident a été vérifié pour tester 33 via un équilibrage manuel des jetons.

• Deadfish ~ peut être testé pour produire 48 localement, en utilisant cet interpréteur . Notez que Deadfish ~ demande au polyglotte de se nourrir de stdin, mais affiche un certain nombre d’ >>invites sur la sortie standard, conséquences inévitables de l’exécution d’un programme Deadfish ~.

• Moorhens 2.0 peut être testé pour produire 60 en utilisant cet interpréteur .

ALGOL 68

Depuis le début de la programmation, ALGOL est probablement le moins connu des quatre langages de programmation de haut niveau - les langages restants de cette distinction nébuleuse étant COBOL, FORTRAN et Lisp. À l’époque, ALGOL était mieux connu dans les milieux universitaires et mathématiques, mais il est aujourd’hui plus connu pour son influence considérable sur les langues modernes. En fait, la plupart des langages pratiques modernes peuvent être décrits comme «semblables à Algol», le C n'étant pas le moindre, qui possède bien entendu sa propre lignée d'influences et de dérivés.

Je suis très heureux d’inclure ALGOL, car c’est un autre tremplin important dans l’histoire de l’informatique que nous devons ajouter à ce monument que nous appelons un polyglotte. C'est des trucs cool.

ALGOL68 est la dernière des trois principales spécifications ALGOL, les autres étant ALGOL60 et ALGOL58. Fait intéressant, la spécification n'a pas de syntaxe fixe, ce qui signifie que les jetons sont définis, mais pas l'orthographe. Cela rend la langue très dépendante de l'interprète, car tout interprète peut utiliser un symbole différent pour initier un bloc de commentaires, par exemple. La spécification décrit le ¢comme initiant un bloc de commentaire. Mais comme il ¢ne figure pas parmi les 127 codes ascii de base, il est compréhensible que l’indicateur de commentaire ne soit pas très utile parmi les interprètes disponibles. Il se trouve que l’interprète de Génie se présente ¢sous la forme suivante #: c’est toute l’ouverture dont nous avons besoin pour surmonter le caractère 1 et créer un polyglotte.

En fait, Genie a trois options de syntaxe de commentaire, les deux autres étant coet comment, les deux étant spécifiées comme écrites en gras. Oui, audacieux. Si nous utilisons l'italique, c'est une variable. Genie a résolu le problème pour nous encore en épelant gras et en majuscule. Et comme il COne figure nulle part dans le polyglotte, nous avons une méthode simple pour cacher le polyglotte à l’analyseur. Si COune langue doit être utilisée ultérieurement, nous pouvons passer à la COMMENTsyntaxe plus détaillée .

Il n'y a pas de commentaire de ligne dans ALGOL - ils sont tous de style bloc, ce qui signifie qu'ils doivent être terminés. Etant donné l'état initial du polyglotte, notre commentaire de bloc ALGOL est ouvert immédiatement et se termine vers la fin de la ligne 1, car Turtlèd est également utilisé #comme jeton de saut. Turtlèd n’a heureusement pas de problème à parcourir les caractères Cet O. La première ligne de la ligne 1 peut donc être insérée COimmédiatement après la seconde #pour lancer un commentaire de bloc gras pour ALGOL68.

À partir de là, nous devons simplement placer COprint("65")quelque part. J'ai choisi la dernière ligne parce que je préférais terminer la ligne par un autre #commentaire et je ne voulais pas que le commentaire se termine au #début de la dernière ligne. Nous suivons donc notre déclaration d’impression ALGOL avec #set #comme dernier caractère du texte polyglotte. Le sen #sest pour alphuck pour équilibrer le pimprimé.

Merci à @ ais523 d’avoir ouvert la fin du texte polyglotte avec la réponse 59 et rendu tout cela possible.

SMBF

Nous avons ajouté un caractère différent à la fin du texte polyglotte pour terminer le dernier commentaire d'ALGOL, et SMBF lisait auparavant le dernier caractère pour obtenir sa réponse. Pour remédier à cela, j'ai dû modifier SMBF pour lire l'avant-dernier caractère en modifiant le code de la ligne 8 [.>-]en ceci [<.>>-]. Il s'agit d'un bloc de code privé SMBF car le MP de BF est à 0 lorsque la boucle est lancée.

Déclencheur

À ce stade, j'ai remarqué un comportement étrange avec SMBF et cela concernait les relations entre ces segments de code et la fin du polyglotte.

• Destination du saut de l’incident: ^_^_

• Destination du déclencheur, plus réponse: X222999

• réponse d'ALGOL68: COprint("65")#s

La réponse d'ALGOL a identifié deux ou trois jetons d'incident dans son segment de code. Le code d'ALGOL a donc dû être inséré avant le segment de code d'Incident. ALGOL a également posé un problème d’alignement prélude s’il figurait en premier dans l’ordre et devait donc être classé deuxième ou troisième. Pendant ce temps, SMBF a eu un échec inexplicable lorsque le code d’incident est entré en dernier, donc Incident a dû passer en premier ou en deuxième. Bien, j’ai réalisé que c’était un problème de logique introductive qui semblait insoluble, alors j’ai voulu rendre l’explicable plus… plicable.

Après avoir traversé SMBF, j’ai trouvé que le problème d’avoir ^ _ ^ _ à la fin était dû à Wise. Le code de Wise ( ~-<~-<~-<<<~-) n'est pas caché derrière une boucle non-exécutante, contrairement à la plupart des polyglottes. Mais il n'y a pas de codes d'impression SMBF impliqués dans le code de Wise. C'était juste changer les valeurs de la mémoire. Cela semblait anodin. Alors quel était le problème alors? C'était ce foutu SM devant le petit ami.

Le code de Wise change les caractères du code sur le point d'être exécuté, et pouvez-vous deviner ce que la valeur ascii voisine ^est? C'est ]. Wise mettait un terminateur de boucle SMBF à la fin du polyglotte, ce qui le faisait tomber dans une boucle infinie. C'est mauvais Mojo.

Après réflexion , je pris la solution de 0 octet au problème et séparé destination de saut de Trigger ( X) de sa réponse ( 222999) et a fini polyglottes ainsi: ~-<~-<~-<<<~-XCOprint("65")#s^_^_2229996#. Cela ne fonctionne que parce qu'aucun caractère n'apparaît consécutivement après le saut de Trigger qui ne soit pas la réponse de Trigger.

Emballer

Ce sont tous les changements majeurs de ce tour. J'ai fait un changement mineur pour supprimer le sujet discuté cà la ligne 1, mais c'est tout pour les changements concernant le golf.

Bonne chance!

Rapport d'incident

#<q>"3"O.sest devenu #<T>"3"O.sparce que detokenizing Tau lieu de qétait plus efficace pour équilibrer

<>{est devenu <>{nddétokenize ndet{␊

Mettez un espace entre }}et +dans #<]}} +<[<.>>-]>[afin de procéder à une décomposition }}+plus économique .

2. V (11 octets)

print(1)#i2

Ce programme affiche 1 en Python 3 et 2 en V.

Juste pour faire avancer les choses et pour lancer ma langue préférée dans le mix dès le début. :)

C'est une réponse très simple.

print(1)#

Il se trouve qu’il s’agit d’un NOP en V. (Heureusement pour moi). Puis i2entre en mode insertion et insère un '2'. Vous pouvez essayer V en ligne ici

Bien sûr, en python

print(1)

imprime '1', et

#i2

est un commentaire.

20. Prélude, 167 octets

#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

Caractères ESC littéraux au même endroit que dans les soumissions précédentes (entre le #et g, et entre le 2et `, sur la dernière ligne), car vous ne pouvez pas désactiver Vim du mode insertion avec des caractères imprimables.

Ce programme imprime 20 exemplaires en Prélude , 19 à Reng (testables ici ), 18 à Cardinal , 17 à Julia , 16 en Pyth , 15 en Meule de foin , 14 en Turtlèd , 13 en Ruby , 12 en Fission , 11 en Befunge-98 , 10 dans Befunge-93 , 9 dans Perl , 8 dans Retina , 7 dans Japt , 6 dans SMBF ,5en Python 2 , Un poirier .4 in> <> , 3 dans Minkolang , 2 dans Vim / V , 1 dans Python 3 eta partridgedans

Le code existant s'annule à peu près dans Prelude, consistant uniquement en des boucles while avec des arguments falsey et une manipulation de pile sur des piles qui ne nous intéressent pas. Mieux encore, il y a une place dans le code qui est un commentaire dans toutes les langues qui les contiennent (entre le #et =#de la soumission précédente). Le plus difficile d’y intégrer Prelude, c’était de générer des nombres avec une seule pile et sans augmenter le nombre d’octets. Ce programme utilise une boucle qui ajoute 45 à chaque élément de la pile et le sort au format ASCII. Ainsi, en plaçant un 5 au-dessus d'un 3 sur la pile, nous obtenons 20en sortie. (Vraiment, 20 est un nombre plus facile à sortir que 19 dans Prelude, alors la réponse 19 affichée m'a en fait un peu aidé.)

30. espaces blancs , 296 octets

#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

␛ représente des évasions littérales.

␉ représente des onglets littéraux.

Ce programme imprime 30 en espaces blancs , 29 en déclencheurs , 28 en Brain-Flak , 27 en Perl 6 , 26 en 05AB1E , 25 en Pip , 24 en Thutu , 23 en Hexagonie , 22 en Sous - charge , 21 en Nim , 20 en Prélude , 19 à Reng (testé ici ), 18 à Cardinal , 17 à Julia , 16 à Haystack en Pyth ,15, 14 à Turtlèd , 13 à Ruby , 12 à Fission , 11 à Befunge-98 , 10 à Befunge-93 , 9 à Perl 5 , 8 à Retina , 7 à Japt , 6 à SMBF , 5 à Python 2 , 4 à> <> , 3 dans le Minkolang , 2 dans le V / Vim et 1 dans Python 3 .

Les espaces blancs sont un autre esolang avec un jeu de caractères limité. Celui-ci ne lit que les tabulations, les espaces et les sauts de ligne.

Donc, une fois que nous retirons tout ce que Whitespace ne lit pas, il nous reste le code suivant:

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

Et le code à afficher 30 est le suivant:

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

Ainsi, les 3 premières lignes du code existant ont reçu des espaces supplémentaires à la fin des lignes pour répondre aux exigences. Notez que les tabulations et l'espace de fin de la ligne 1 se trouvent au milieu de la ligne pour répondre aux besoins de> <>.

L'espace de la ligne 2 a été changé pour un onglet ici. Cela semble fonctionner de manière identique à un espace pour les langages 2D, mais visuellement, il ne s'aligne plus. ¯ \ _ (ツ) _ / ¯

Après les instructions de sortie 30, le jeu a été contraint de faire en sorte que le reste des espaces et des sauts de ligne nécessaires permettent d'effectuer des opérations inutiles et de les compiler correctement.

Les espaces blancs ont des instructions qui marquent / vont à un emplacement de code avec une étiquette qui permet un nombre arbitraire d'onglets et d'espaces, ce qui aide à créer des espaces de la longue ligne. Il commence et se termine également par un saut de ligne, ce qui nous a permis de remonter certains des sauts de ligne des lignes 3 à 6.

La dernière ligne ne peut pas avoir de saut de ligne sans casser Retina, elle a donc pour instruction de faire des calculs arbitraires et des manipulations de pile.

Voici le code complet avec les espaces, les tabulations et les sauts de ligne remplacés par notre notation:

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

Et voici une version commentée du Whitespace:

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

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

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

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

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

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

Modifications: Hexagony s'avère ignorer les onglets comme des espaces, contrairement à ce que je disais auparavant. @ ais523 a eu la gentillesse de mettre à jour @ Kenney Hexagonizer pour prendre en compte les échappements littéraux et les onglets. J'ai dû le modifier pour corriger mon affirmation précédente selon laquelle les onglets étaient lus comme des no-ops et pour remplacer les échappements littéraux .car le ␛caractère était plus large que les autres caractères, ce qui rendait l'hex légèrement plus mal aligné. Ici le lien .

Et voici notre hex corrigé:

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

Enfin, j'ai joué au golf avec des personnages inutiles, ajoutés la plupart du temps pour aligner les parenthèses Prelude et les hexagones Hexagony.

Le code de Nim est de retour à echo 21partir deecho 5+5+11

Hexagony #@46est maintenant#46

Le code de Hexagony est de retour à /+23!@=partir de/+23!@

L'alignement parenthétique de Prelude est (9) or (13)devenu(9)and(13)

Eh bien, c'est tout ce que j'ai. Bonne chance à tous!

100. Cerveau, 2953 octets

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

Partition VIP ( imprimante numérique polyvalente) numérique ): .002953 (pour améliorer, la prochaine entrée ne doit pas dépasser 3042 octets)

Fatigué

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

Vérification

Essayez-le en ligne! Langues non disponibles sur TIO:

• Japt, 7 en ligne .
• Reng, 19 en ligne .
• Deadfish ~, 48 locaux .
• Moorhens, 60 locaux . utilisez moorhens.py de la branche v2.0-dev
• Morse, 73 local
• Archway, 74 local
• Trefunge-98, 76 locales . Utilisez -d 3 -v 98pour Trefunge-98.
• Objeck, 83 local
• zkl, 85 local
• PingPong, 88 local
• RunR, 90 local
• Cood, 91 ligne
• Set, 93 ligne
• Emotinomicon, 94 ligne
• EmojiCoder, 96 ligne
• Archway2, 98 local Je ne peux pas tester Archway2 car je ne dispose pas du compilateur C approprié, mais stasoid a confirmé que cela fonctionnait dans archway2

Explication

Je ne peux pas croire que nous avons réussi à 100 langues. Je voudrais juste prendre le temps de remercier tout le monde qui a été impliqué dans ce processus. Ca a été une promenade amusante et j'espère en ajouter 100 autres avec vous.

Brainbool est dans mes yeux depuis un moment. Cependant, depuis brainbool ne peut sortir que deux nombres, 1et 0je n’ai pas pu les ajouter jusqu’à présent (je n’étais pas là pour 10 et 11).

Brainbool est comme un brainfuck, sauf qu'au lieu d'envelopper en 256, il s'enroule à 2. Brainbool n'a pas non plus de -car il est redondant avec le +. Notre code brainbool à la sortie 100 est assez simple:

+.+..

Afin de masquer les sorties pour brainfuck, nous ajoutons une boucle et un moins:

+-[.+..]

Il ne reste plus qu’à trouver une place pour le code. Mon endroit de choix était le premier +au plus haut niveau du code brainfuck de la ligne 8. Pour remplacer, nous avons ajouté notre code et un code +-+qui agit comme un +brainfuck et un noop dans le brainbool.

+-[.+..]+-+

Cubix

J'ai mis mon code avant la capsule Cubix, ce qui a provoqué le déplacement d'un miroir dans le chemin du pointeur. Afin de résoudre ce problème, j'ai avancé la capsule de quelques pas devant le miroir incriminé et tout allait bien.

Étonnamment, rien d’autre n’a brisé le moindre incident, pas même.

27. Perl 6 , 235 octets

#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

␛ représente un caractère ESC littéral, comme d'habitude.

Ce programme imprime 27 en Perl 6 , 26 en 05AB1E , 25 en Pip , 24 en Thutu , 23 en Hexagonie , 22 en Sous - charge , 21 en Nim , 20 en Prélude , 19 en Reng (testé ici ), 18 en Cardinal , 17 en Julia , 16 ans en Pyth , 15 en botte de foin , 14 en tourteau , 13 en rubis , 12 en Fission , 11 en Befunge-98 , 10 en Befunge-93 , 9 en Perl 5 , 8 en rétine , 7 en Japt , 6 en SMBF , 5 en Python 2 , 4 en> <> , 3 en Minkolang , 2 en Vim / V , 1 en Python 3 et (comme c'est Noël) a partridgedans A Pear Tree .

La syntaxe soulignant que Stack Exchange produit pour cette réponse est complètement fausse. #`<est l'un des nombreux marqueurs de commentaires multilignes de Perl 6 et se termine par #>, ainsi, le seul code qui s'exécute réellement dans Perl 6 est très simple say 27. J'ai choisi ce marqueur de commentaire en particulier car, <>dans la plupart des langues, la paire qui ne correspond <pas ne casse pas les langues, telles que Retina, qui tente de l'analyser.

Je ne suis plus tout à fait sûr du fonctionnement de l'Hexagony. Quand cela s'est cassé, j'ai changé l'un des personnages qu'il utilisait d'un a +à un 0pour voir s'il était touché; s’avère que c’était, et que cela corrige le programme, mais je ne sais pas pourquoi (je sais que c’est cassé à cause de #la ligne d’exécution, mais on ne sait pas trop pourquoi supprimer les +correctifs). (Le personnage en question est également analysé par Thutu, mais heureusement, cela ne change rien au fonctionnement du programme Thutu, car à ce stade du programme, tout ce qui n'est pas précédé d'un =est copié littéralement dans le répertoire de travail. string.) Notez que0and+4 partir d'une ligne précédente est devenu0and 4, pour en faire un caractère plus court du point de vue de Hexagony (Hexagony ne voit pas les espaces); c'est pour compenser le #|devenir d'une ligne précédente #`<`|, ce qui est un caractère plus long du point de vue de Hexagony (car elle ne voit pas non plus les guillemets arrières). Notez que le code n'a plus que cinq octets pour augmenter la longueur du côté hexagone et tout casser du code actuel hexagone. Je recommanderais de toute façon de le faire et de simplement refaire la section Hexagony du code; il sera probablement plus facile, plutôt que difficile, de tout installer après une extension.

Certaines autres langues ont également changé, principalement pour ajouter suffisamment de robustesse pour que je puisse insérer du code arbitraire dans la dernière ligne. $//est un marqueur de commentaire dans Japt qui permet des espaces plus tard sur la ligne, ce qui rend le programme ajouté moins fragile dans Japt (pendant ce temps, se //casse s'il y a des parenthèses fermantes plus tard sur la ligne et l'espace est une sorte de parenthèse fermante dans Japt). Une paire d'espaces est un marqueur de commentaire dans Pip, ce qui signifie que le code Pip peut être considérablement simplifié ici. Cela signifie également que nous pouvons simplifier le 05AB1E en un simple"26 . Retina a besoin de la cinquième ligne pour être un regex légal qui sait bien faire correspondre les choses (les| conséquent, cela concerne Retina); il est analysé différemment de la ligne correspondante dans l'entrée précédente, mais d'une manière tout aussi appropriée. Le Cardinal est également un peu plus simple que dans les entrées précédentes, mais il s’agit d’une pure coïncidence avec l’alignement vertical de tous les éléments, et le changement consiste à coder sans rien faire.

En supposant que vous refaire le Hexagony (vous aurez probablement), il y a des endroits sûrs pour ajouter du code sur tous les trois dernières lignes: l' 3en #3]#est que pour Hexagony (et facilement modifiés); la grande majorité des langues ignore l’espace entre les lignes #et "la dernière ligne; et rien n'analyse vraiment la fin de la cinquième ligne autre que Retina. (Il existe de nombreux autres endroits où du code peut être ajouté, mais ce sont probablement les plus pratiques.)

31. SNUSP modulaire , 326 octets

Programme

#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

Comme d'habitude, il ␛s'agit d'un caractère ESC littéral et d' ␉un onglet littéral.

Fatigué

Ce programme imprime 31 en SNUSP modulaire, 30 en espace, 29 en déclencheur, 28 en Brain-Flak, 27 en Perl 6, 26 en 05AB1E, 25 en Pip, 24 en Thutu, 23 en Hexagony, 22 en Sous-charge, 21 en Nim , 20 en prélude, 19 à Reng, 18 à Cardinal, 17 à Julia, 16 à Pyth, 15 à Haystack, 14 à Turtlèd, 13 à Ruby, 12 à Fission,11dans Befunge-98, 10 dans Befunge-93, 9 dans Perl 5, 8 dans Retina, 7 dans Japt, 6 dans SMBF, 5 dans Python 2, 4 dans> <>, 3 dans Minkolang, 2 dans V / Vim et 1 en Python 3.

Vérification

Pourquoi pas de liens dans la liste? Parce que je travaillais sur quelque chose pour rendre les tests beaucoup plus faciles, un pilote de test qui exécute le programme dans la plupart des langues répertoriées ici et imprime le résultat. Nous espérons que cela facilitera l’ajout de futures langues au polyglotte. Vous pouvez obtenir les résultats de ce programme pour 28 langues sur 31 en exécutant le lien TIO suivant (qui est un pilote de test écrit en mélange de Bash, Perl et A Pear Tree):

Essayez-les en ligne!

Le lien produit également le bloc de code mis en forme ␛/ ␉vu ci-dessus et formate le code en hexagone pour vous:

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

Trois langues manquent: V est trop lent et Reng et SNUSP modulaire ne sont pas installés sur TIO. Heureusement, tous les trois ont des interprètes en ligne:

• Vous pouvez tester le programme dans V / Vim (sortie prévue: 2) ici sur TIO.
• Il y a un interpréteur Reng en ligne (sortie prévue: 19) ici .
• Il existe un interpréteur SNUSP modulaire en ligne (sortie prévue: 31) ici . (Il s'agit d'un interpréteur SNUSP, mais Modular SNUSP est le dialecte qu'il met en œuvre, comme l'indiquent les @panneaux sur toute la page.)

Tous les trois produisent la sortie prévue, les 31 programmes sont donc correctement testés. (Une chose qui me préoccupe légèrement est de savoir si le programme Whitespace se termine correctement; cependant, les espaces sont identiques à ceux de la soumission précédente, ils ont donc raison ou tous les deux sont incorrects. à tort, les deux programmes sont susceptibles d'être réparés de la même manière.)

Explication

Tout d’abord, l’hexagone, qui semble toujours avoir besoin de changer. C'est en réalité beaucoup plus simple qu'avant; J'ai déplacé le code Hexagony juste après le code Trigger, ce qui signifie qu'il est très proche de la fin du programme, et la "capsule" Hexagony qui affiche 23 sorties et s'exécute presque immédiatement. La dernière ligne semble généralement être un bon endroit pour placer la capsule, car cela signifie moins de commandes qui pourraient potentiellement perturber le fonctionnement de Hexagony.

Toutes les autres modifications concernent l'ajout du code Modular SNUSP. La première chose à noter est que SNUSP commence à s’exécuter au premier $caractère du programme et est une langue 2D qui se termine après avoir quitté le programme, et donc en plaçant le programme SNUSP à la fin de la longue ligne le code Thutu, à un moment où Thutu acceptera presque tout), nous pouvons nous assurer que SNUSP ne verra aucun code d’autres langues et que la plupart des autres langues ne se soucieront pas de SNUSP. Une langue qui a fait des soins était Perl 6, qui est l' analyse équerres; J'ai placé une< juste avant le code SNUSP pour le rendre heureux (car les crochets étaient naturellement presque identiques). L’autre langue qui s’intéresse est SMBF;.sorties dans SMBF et SNUSP, et nous ne voulons pas créer de sortie supplémentaire. Heureusement, comme l’a vu SMBF, ce programme est<.>>[…] suivi du code SNUSP, c’est-à-dire que l’élément de bande en cours est 0. Vous devez donc placer le code SNUSP entre crochets "commente", du point de vue de SMBF.

Quant au code lui-même, il utilise une astuce bien connue pour écrire des constantes dans Modular SNUSP dans lequel vous écrivez un grand nombre de commandes "procédure de démarrage" dans une ligne et créez efficacement une sorte de nombre de base-Fibonacci. L'idée de base est que +code le nombre 1; @additionne le nombre représenté par le code après celui-ci et le nombre représenté par le code après celui-ci moins son premier caractère; et =est un no-op ( @=va donc doubler le nombre à sa droite). Dans ce système, j'ai choisi @@@@=+@@@=+#comme représentation du nombre 48.

Il y a un problème ici, cependant; la méthode standard d'écriture des constantes dans SNUSP laisse le flux de contrôle derrière le début du programme, et avec un oneliner (que je voulais écrire ici pour des raisons évidentes), il n'y a aucun moyen de modifier l'adresse IP pour qu'elle pointe dans une direction quelconque, mais à droite. Cela signifie en quelque sorte que nous devrons faire en sorte que l'adresse IP réponde à la définition de constante constante et continue vers la droite, sans que le programme ne se ferme (ce qui #serait normalement le cas). Afin de résoudre ce problème, j’ai soigneusement utilisé une définition du nombre pour laquelle +a toujours été précédée =. Cela signifie que je peux écrire du code pour définir la deuxième cellule sur 48 via @@@@=>+<@@@=>+<#, en sachant qu'aucune >commande ne sera ignorée par un@commande (et donc nous gardons le contrôle du pointeur de la bande). De plus, nous savons qu’au final #, la première cellule de bande aura toujours sa valeur initiale. Par conséquent, nous pouvons utiliser la première cellule de bande en tant que marqueur pour savoir s'il faut revenir à la définition de procédure ou continuer vers la droite (nous sommes dans une tonne de procédures lorsque nous le faisons, mais nous quittons le programme en abandonnant la procédure. bord de sorte que cela n’a aucune importance).

Le code SNUSP final est donc $+@+-@@@@=>+<@@@=>+<?#>+.--.. Le $marque le début du programme. +@+-définit le premier élément de la bande sur 1 ( ++-, mais une fois que la procédure a commencé @, le code sera exécuté à partir de maintenant -, ce qui ramènera l'élément de la bande à 0. ?#met fin à la procédure uniquement si le premier élément de la bande est différent de zéro; nous finissons par nous retrouver après le #deuxième élément de bande défini sur 50 (48 de la définition de constante, plus 2 des deux >+<rencontrés en allant à droite par la suite). Il ne reste plus >+.--.qu'à sortir les codes ASCII 51 ( 3) et 49 ( 1), et tomber du bord du programme ( ]est un no-op dans SNUSP, et /reflète le flux de contrôle verticalement afin qu’il s’écoule du bord supérieur du programme); ce bit fonctionne de manière identique à un brainfuck.

11. Befunge 98 , 102 octets

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

Impressions:

• 1 en Python 3
• 2 dans Vim - Cela prend un certain temps pour une sortie pour une raison quelconque ...
• 3 dans Minkolang v0.15
• 4 dans > <>
• 5 en Python 2
• 6 en SMBF
• 7 dans Japt
• 8 dans la rétine
• 9 en Perl
• 10 dans Befunge 93
• 11 dans Befunge 98

Pour être tout à fait honnête, je ne sais pas pourquoi le code Vim prend 1 minute pour sortir. En outre, aucune idée du fonctionnement de Retina.

Explication:

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

Choses à noter:

• Le 0prochain à bn'est pas strictement nécessaire dans l'état actuel du code et la pile a été effacée. Il peut être supprimé si nécessaire, mais permet une autre manipulation de pile au préalable dans le cadre d'un programme futur possible.
• Le _q@est là dans le cadre de la rétine (cela ne fonctionne pas sans elle, ne me demandez pas pourquoi). L’ajout de qpermet également au code '98 d’exécuter une topération qui divise l’IP (avec l’impression 8 du programme Retina au lieu de 7)
• Ce _n'est pas simple >car cela gâcherait la partie SMBF.

Edit: Je viens de me rendre compte que le _q@devrait probablement être @00(où 0 peut être un caractère quelconque) pour rendre le programme plus flexible dans le futur. Je suis trop paresseux (et fatigué) pour changer tous les liens pour le moment. Je finirai par y arriver ...

Edit 2: Je ne m'attendais pas à 6 autres réponses aussi rapidement. Je suppose que ça reste tel quel. Excellent travail à tous!

35. INTERCAL (C-INTERCAL), 631 octets

#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

␉est un onglet littéral, ␛un caractère ESC littéral; Stack Exchange modifierait le programme autrement. Je vous recommande de copier le programme à partir de la zone "entrée" du lien TIO ci-dessous, si vous souhaitez y travailler.

Essayez-les en ligne!

Fatigué

Ce programme imprime 35 en INTERCAL, 34 en Rail, 33 en Incident, 32 en Whirl, 31 en SNUSP modulaire, 30 en Whitespace, 29 en Trigger, 28 en Brain-Flak, 27 en Perl 6, 26 en 05AB1E, 25 en Pip. , 24 à Thutu, 23 à Hexagony, 22 à Underload, 21 à Nim, 20 à Prelude, 19 à Reng, 18 à Cardinal, 17 à Julia, 16 à Pyth,15 dans la botte de foin, 14 dans la tourteau, 13 dans le rubis, 12 dans la fission, 11 dans le Befunge-98, 10 dans le Befunge-93, 9 dans le Perl 5, 8 dans la rétine, 7 dans le Japt, 6 dans le SMBF, 5 dans le Python 2, 4 dans> <>, 3 dans Minkolang, 2 dans V / Vim et 1 dans Python 3.

Vérification

La plupart des langues sont testées par le pilote de test illustré ci-dessus. Vous pouvez tester Reng ici et SNUSP modulaire ici ; ils produisent respectivement 19 et 31, selon les besoins. J'ai testé Incident localement sur mon propre système, en utilisant l'interprète officiel.

Notez que j'ai ajouté quelques modifications au pilote de test afin de faciliter la détection des caractères masqués. divers octets NUL se sont glissés dans la sortie du programme dans certaines langues. J’ai décidé que ce n’était probablement pas un problème, car a) un grand nombre de soumissions l’ont été et b) les interprètes de Befunge semblent ajouter des octets NUL supplémentaires alors que rien dans le programme ne laisse supposer que 'ai raté quelque chose), cela doit donc durer depuis des lustres et fait probablement partie du fonctionnement de l'interprète. (Notez que le code des langues dans lesquelles les octets NUL - les fichiers Befunges et Minkolang sont toujours disponibles - n'a pas été modifié pour cette soumission.)

La soumission précédente de Rail est fermée via un crash, ce qui est interdit, mais cela est facilement réparable (en ajoutant un #à la fin du programme Rail et en ajustant l'Hexagonie pour correspondre) et je ne l'ai donc pas considéré comme un problème majeur. Le rail dans cette solution se ferme correctement.

Explication

Comment fonctionne le code INTERCAL

INTERCAL analyse l'intégralité du programme. Cependant, les erreurs de syntaxe sont des tâches d’exécution exécutées dans INTERCAL et non pas au moment de la compilation. Elles sont souvent utilisées pour créer des commentaires. (Si une erreur de syntaxe tente de s'exécuter, le programme provoquera l'erreur ICL000I, contrairement à ce que prétend Wikipedia à tort. Mais si vous pouvez empêcher son exécution de s'exécuter - et INTERCAL dispose de nombreux moyens d'empêcher l'exécution de commandes - heureusement ne pas exécuter sans causer de problème.)

En tant que tel, nous pouvons empêcher les ordures à la fin du fichier en cours de sortie simplement en quittant le programme explicitement d’abord (ce qui est néanmoins nécessaire, car INTERCAL se bloque si la fin du programme est atteinte sans commande de sortie explicite). La gestion du début du programme est plus intéressante et exploite un bogue d'analyse. Vous pouvez écrire quelque chose comme DO %20 READ OUT #8une sortie VIIIavec une probabilité de 20% (et sinon, ne rien faire). Autant que je sache, C-INTERCAL analyse le% unique de la deuxième ligne comme indiquant une probabilité de 0% que la première commande s'exécute, et finit donc systématiquement par ne pas l'exécuter à chaque fois. (Je ne suis pas sûr de savoir pourquoi cela est analysé comme ça, mais regarder le code compilé montre qu'il génère un nombre aléatoire et le compare à 0.)

Voici à quoi ressemblait le programme INTERCAL avant de l’adapter au reste du polyglotte:

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

C'est assez simple: instancier un tableau à 2 éléments; définissez les éléments sur 52 et 32 ​​(décimal) respectivement (le codage de chaîne d'INTERCAL est mieux laissé de côté; j'ai oublié comment cela fonctionne et j'ai dû faire diverses expériences pour comprendre pourquoi ces nombres codent 35); lisez-le sur la sortie standard; et quittez le programme. J'ai ajouté un PLEASE supplémentaire à la fin afin de mettre fin à l'instruction GIVE UP, en commençant une nouvelle instruction pour la corbeille à la fin du programme, tout en conservant des limites acceptables pour une conversation polie. Bien entendu, INTERCAL ne ressemble pas vraiment à cela dans le produit fini; Je vais expliquer pourquoi comme nous allons.

Enterré sous une charge d' Ses

Le problème le plus évident avec le programme INTERCAL est qu’il contient la lettre S. C'est à peu près inévitable, car il n'y a aucun moyen d'indexer un tableau sans utiliser la lettre en question. Cependant, il Sy a une commande de sortie dans Underload, et il n'y a aucun moyen de l'empêcher d'analyser l'intégralité du programme. La seule solution consiste à placer le code INTERCAL entre parenthèses, l'équivalent d'un littéral de chaîne pour Underload, afin qu'il ne s'exécute pas immédiatement.

Cependant, nous avons deux ^caractères à la fin du programme, qui exécutent le code Underload; donc ces Ses vont être exécutés de toute façon si nous ne faisons rien à ce sujet. J'aurais pu le changer pour un autre personnage, mais j'ai décidé qu'il était plus facile de protéger le code afin qu'il devienne sans objet. aéchappe à une chaîne dans Underload (ce qui signifie que ^lors de l’exécution de la chaîne, elle ne la détournera simplement plus, au lieu de produire des effets secondaires néfastes). Nous en avons déjà un adans le saycode utilisé dans Perl 6 (ce qui, dans cet agencement du code, est en réalité suffisant en raison de changements non liés). Cependant, afin que les gens ne doivent pas compter sur cela, j'ai ajouté un autreaà la fin de la ligne (je voulais quand même un personnage rendre visible ce qui serait autrement des espaces de fuite, et parce que Hexagony avait besoin de rembourrage tel quel; notez que Hexagony était assez facile à corriger dans ce programme, et ne besoin d'une discussion séparée). Le code Underload est donc un peu moins fragile qu'il aurait pu l'être.

Prélude à beaucoup de travail et de confusion

Ah, prélude. Ce n’est pas normalement la langue la plus difficile, mais c’était vraiment cette fois. Il existe deux problèmes réels: le premier est que l’ajout de parenthèses supplémentaires sur une ligne très longue risque de perturber le flux de contrôle du programme Prelude (car elles créent l’équivalent d’une whileboucle), et le seul problème consiste à les empêcher de doubler. verticalement (responsable de la plupart des déplacements aléatoires des espaces sur les lignes). Notez que le Whitespace m'a aussi posé quelques problèmes, mais ce programme est équivalent au précédent du point de vue de Whitespace, il s'agissait donc plutôt de "réparer le prélude sans rompre le blanc".

Je ne sais pas trop comment fonctionne le prélude à ce stade. Plusieurs correctifs sont prévus, comme le 0 près du coin inférieur gauche, mais ils ne fonctionnent clairement pas comme je le pensais. (Le code de Julia a également fini par être placé au bas de la ligne parce que les parenthèses dans sa printdéclaration étaient vraiment difficiles à gérer.) Peut-être devrions-nous simplement laisser le mystère.

Panne dans un réacteur à fission

Bien que les modifications ci-dessus concernaient des problèmes assez subtils, difficiles à résoudre, il existe un problème beaucoup plus évident; DOREADOUTcorrespond à l'expression rationnelle R...O, et entraînera donc une fission de produire une sortie indésirable sur le quatrième cycle, ce qui n'est pas assez de temps pour produire la sortie prévue de 12. Et INTERCAL n'a qu'une seule instruction qui produit une sortie (sauf si vous comptez le crash comme une sortie). Une solution à ce problème consiste à essayer d'ajouter un espace blanc entre READet OUT, afin de nous donner le temps d'intercepter la sortie, mais cela rend Whitespace en colère. Alors pendant un moment, j'ai pensé que ce programme était impossible; R, L, UEt Dsont tous les points d'entrée dans Fission, et tous capables de potentiellement exécuter du code problématique, et les mots clés INTERCAL doivent être en majuscules.

Cependant, il existe un correctif, et un assez surprenant. Dans le cadre d'un effort d'internationalisation, C-INTERCAL accepte les mots clés dans plusieurs langues, avec une prise en charge de l'anglais et du latin. Nous ne pourrions pas éviter Scomme ça, mais nous pouvons éviter O; FACest un substitut parfait DO, et LEGERE EXsignifie également la même chose que READ OUT. (Le programme a donc fini par un mélange d'anglais et de latin, mais c'est correct; cela ne le rend pas moins lisible.) En tant que tel, nous pouvons laisser Fission devenir fou dans le coin en bas à droite, et ne le laisser produire aucun sortie. Nous pouvons changer le code de fission réel pour finir avec *plutôt que;, qui quitte l’ensemble du programme plutôt qu’un seul thread; ce code s'exécute assez rapidement, il quitte donc le programme avant que tous les points d'entrée parasites aient le temps de causer des dommages.

Tricot 6, Perl 6

Le problème suivant: Les commentaires Perl 6 fonctionnent en faisant correspondre les mots <et >. L'opérateur d'affectation d'INTERCAL est <-. Heureusement, cela ajoute des crochets d' ouverture supplémentaires . Je pourrais donc simplement ajouter quelques crochets de fermeture pour les annuler dans un emplacement non analysé du programme (juste après le code Pip, dans ce cas).

Cependant, je ne voulais pas changer le budget des espaces, mais le déplacement du code de Julia (pour Prelude) a fini par ajouter un espace supplémentaire à la dernière ligne. Je devais en enlever un de quelque part. Le double espace est un marqueur de commentaire dans Pip, je ne pouvais donc pas les changer; la seule option restante est l'espace dans say 27. Les golfeurs Perl 5 penseraient immédiatement «bon, say+27alors faites- le bien» (unary +se révèle étonnamment souvent pratique!), Mais malheureusement, la syntaxe Perl 6 n’est pas valide.

Ce que nous pouvons faire, cependant, est de passer sayde la syntaxe de fonction à la syntaxe de méthode. Les littéraux entiers ont un tas de méthodes, y compris une pour les imprimer, donc 27.sayun programme parfaitement valide de la même longueur.

Être carré? Ne pas être là

Le problème suivant est donc que j'ai ajouté un supplément .au programme. Les utilisateurs de SMBF sauront qu'il s'agit clairement d'un problème dans cette langue, produisant une sortie parasite (octets NUL dans ce cas). Le dernier programme produisait déjà une .sortie égarée, mais cela ne veut pas dire que je ne devrais pas en profiter pour le réparer.

L'idée de base est de créer une boucle SMBF pour commenter les instructions incriminées. Cela signifie déplacer les crochets. Je les ai pris dans le code SNUSP (car ils n'étaient là que pour incident de toute façon, et Incident ne se soucie pas de savoir où ils se trouvent dans le programme), et j'ai placé la parenthèse d'ouverture au début du code INTERCAL, et crochet de fermeture juste avant le déclencheur (masquant ainsi parfaitement les deux .s).

Malheureusement, les crochets ont un sens pour Retina. il voit […<-#…et dit "cela n'a aucun sens, vous ne pouvez pas créer cette plage parce que <cela ne vient pas avant #". Heureusement, ceci est facilement réparable avec une barre oblique inversée placée de manière stratégique.

L'incident au centre du programme

C'était la dernière réponse, et cela va probablement arriver à plusieurs reprises à partir de maintenant; Diverses chaînes de caractères se sont produites de manière aléatoire trois fois et se sont déplacées autour du centre du programme du point de vue de Incident.

Le jeton le plus urgent à manipuler était 1#, qui apparaît trois fois si vous apportez ces modifications naïvement: #= >␉1#au début de la troisième ligne __DATA__=1#, et echo 21#. Pourquoi c'est un problème? Parce que 1#la troisième ligne se chevauche #vjuste après, et que deux jetons qui se chevauchent ne sont comptés. Et #vc'est le jeton que nous utilisions pour commenter le code avant la sortie du programme Incident! J'ai corrigé cela en insérant un extra 1#très près de la fin du programme (seulement trois caractères le suivent); Aucune des langues qui analysent cette partie du programme ne fait quoi que ce soit avec elle.

Il y avait divers autres jetons problématiques à traiter. Un couple étaient des lettres simples, Pet U; Je me suis occupé de ces problèmes en changeant un ou deux numéros de remplissage dans le code de l'incident de xà Pou Urespectivement, en donnant une quatrième copie. La modification apportée au code de fission laisse *un jeton, mais elle est divisée de façon différente de la normale, apparaissant deux fois avant le code de l’incident et une seule fois par la suite. Au lieu de le supprimer, je l’ai donc utilisé pour équilibrer partiellement le nouveau LEjeton apparaissant dans le code INTERCAL. C’est suffisant pour ramener le centre du programme sur une0ojeton. Bien entendu, les modifications apportées au programme risquent fort de perturber ce processus. (Mes tentatives pour obtenir Incident sur TIO ont échoué car libdivsufsort n’était pas disponible sur ce site. Il semble donc que nous pourrions tirer parti d’un nouvel interpréteur, notamment en JavaScript, afin de pouvoir fonctionner en ligne. Si cela vous intéresse, jetez un œil à cette page. question .)

1. Python 3 (8 octets)

print(1)

Ce programme imprime 1 en Python 3.

Commencer avec Python 3 parce que je sais que c’est bon pour les polyglottes et que l’on peut le prendre dans différentes directions (j’ai voulu aussi que la première réponse soit dans un langage relativement normal, plutôt qu’un esolang absurde difficile à polygluer avec).

10. Befunge , 95 octets

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

Il y a un caractère ESC littéral entre jet dsur la dernière ligne (grr, @ ais523). Ce n'est pas inclus dans ce code. Pour obtenir le code actuel, veuillez vous rendre sur le Try it onlinelien.

Ceci en 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 rétine, 9 en perl et 10 en Befunge.

Ce code partage *avec Retina et .avec Minkolang et SMBF.

Essayez-le en ligne

Explication

Programme actuel

#v02^
    @
    .
    *



    t
    5
#v02^

La dernière ligne a été écrite pour plus de clarté (le terrain de jeu de Befunge est cyclique.)

#

Trampoline, saute v

02^

Poussez 0puis 2en pile et montez.

5t*.@

Push 5, no-op, multiplier deux éléments de la pile ( 2et 5), imprimer, terminer le programme.

21. Nim (161 octets)

#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

Deux <ESC>s, entre 8det 2`sur la dernière ligne. Vous pouvez dire que mon précédent joueur était pressé au golf, parce que je me suis réveillé ce matin et que je me suis rendu compte que je pouvais en enlever un plus grand nombre. J'avais 152 octets, mais cela ne semble fonctionner que dans Perl 5.24.0, aussi, dans l'intérêt de la compatibilité avec TIO, j'ai conservé l'expression originale.

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 rétine, 9 en Perl, 10 en Befunge-93, 11 en Befunge -98, 12 en Fission, 13 en Ruby, 14 en Turtléd, 15 en Meule de foin, 16 en Pyth, 17 en Julia, 18 en Cardinal, 19 en Reng, 20 en Prélude et 21 en Nim .

Notez que Nim sur ideone.com utilise la version 0.11.2, qui est un peu trop ancienne, car ce programme repose sur #[ ... ]#des commentaires multilignes ajoutés au début de 2016.

Grâce à l'interpréteur Windows de Cardinal, mon flux de travail se compose désormais de deux ordinateurs portables et d'un Python http.serverentre les deux.

Edit - quelques astuces supplémentaires:

• Au 8début de la dernière ligne, vous devez définir la limite de Retina sur les 8 premières correspondances. Sinon, Retina produirait 2. Notez que cela signifie que la regex de dernière ligne doit seulement correspondre au moins 8 fois dans l'avant-dernière ligne maintenant, au lieu de 8 - pendant mon ingérence, j'ai modifié Prelude pour que Retina fonctionne correctement, mais il s'est avéré que ce n'était pas nécessaire à la fin. .
• La citation qui ne correspond pas à la fin de la première ligne est telle que Pyth ne se plaint pas de la syntaxe non valide pour le reste du code.
• Si vous modifiez la deuxième ligne, vous devrez peut-être changer le 6@pour Minkolang, ce qui fera que le pointeur sautera de 6 espaces pour atterrir sur le fichier ^.
• Il y a une paire de []maintenant, donc SMBF doit être sur une cellule 0 avant qu'il ne frappe le [, ou une alternative dont l'intérieur a besoin pour effacer la cellule.

Il y a probablement plus à %jouer au golf (même maintenant, je vois un espace perdu avant le cardinal), mais je devrais vraiment arrêter de jouer au golf aux petites heures du matin.

51. Assembly (x64, Linux, AS) , 1086 octets

#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

␉est un onglet littéral, ␛un caractère ESC littéral; Stack Exchange modifierait le programme autrement. Je vous recommande de copier le programme à partir de la zone "entrée" du lien TIO ci-dessous, si vous souhaitez y travailler.

Voulez-vous en savoir plus? Essayez le chat polygot !

Essayez-le en ligne!

Score VIP ( Imprimante numérique polyvalente ): .008186 (pour améliorer, la prochaine entrée ne doit pas dépasser 1151 octets)

Ce programme imprime 51 dans Assembly, 50 dans Bash, 49 dans Octave, 48 dans Deadfish ~, 47 dans Lily, 46 dans Cubix, 45 dans PicoLisp, 44 dans alphuck, 43 dans réticulaire, 42 dans le mal, 41 dans le cerveau *** , 40 en Minimal-2D, 39 en CoffeeScript, 38 en C, 37 en C ++, 36 en Labyrinth, 35 en INTERCAL, 34 en Rail, 33 en Incident, 32 en Whirl,31 en SNUSP modulaire, 30 en blanc, 29 en déclencheur, 28 en Brain-Flak, 27 en perl 6, 26 en 05AB1E, 25 en pip, 24 en thutu, 23 en hexagone, 22 en sous-charge, 21 en Nim, 20 en Prélude, 19 à Reng, 18 à Cardinal, 17 à Julia, 16 à Pyth, 15 à Haystack, 14 à Turtlèd, 13 à Ruby, 12 à Fission, 11 à Befunge-98,10 dans 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 et 1 en Python 3.

Vérification

La plupart des langues sont testées par le pilote de test illustré ci-dessus.

• Reng peut être testé jusqu'à la sortie 19 ici .

• Le SNUSP modulaire peut être testé pour produire la sortie 31 ici .

• La forme du cube de Cubix vu ici

• L'incident est contrôlé en maintenant les jetons en équilibre, comme décrit dans les réponses précédentes.

• Pour Deadfish ~, peut être testé pour produire 48 avec cela . Notez que Deadfish ~ demande au polyglotte de se nourrir de stdin, mais affiche un certain nombre d’ >>invites sur la sortie standard, conséquence inévitable de l’exécution d’un programme Deadfish ~.

• L'assemblage peut être testé jusqu'à la sortie 51 ici

Merci et félicitations

Lorsque la réponse «50 en 1» de @ ais523 a été annulée, il y a 2 semaines, une larme a coulé sur ma joue. C'était trop beau Et c'était à Bash. C'était trop parfait.

Je me suis tourné vers ma femme et leur ai dit: «Je pense que le polyglotte est terminé», ressentant une immense fierté.

Elle s'est retournée pour me regarder dans les yeux, s'est arrêtée un instant et a dit: «Bien. Maintenant, sortez les poubelles.

Ce qu'elle voulait dire, c’est qu’elle ressentait une joie profonde pour moi et mes amis Internet. Merci et félicitations à tous.

Explication d'assemblage

Dans les jours qui ont suivi, mon esprit revenait sans cesse à quelque chose que @ ais523 avait dit dans un chat polyglotte peu de temps avant de publier Bash. Il a souligné que certains types d'assemblage utilisent des #commentaires de ligne et /*des commentaires de bloc. Eh bien, c’était suffisant pour que je perde lentement l’esprit pendant les 2 prochaines semaines.

Il existe une sorte de défi implicite chez les polyglottes pour inclure les langages légitimes. J'utilise le terme légitime ici très vaguement, mais je pense que nous pouvons tous comprendre ce que je veux dire. C’est une chose d’inclure Brainf ***, mais c’est tout à fait d’inclure Mathlab ou R. Assembly appartient certainement à cette dernière catégorie, et je ne pouvais y renoncer. Mais je ne savais rien de l’Assemblée, c’était donc une bataille difficile.

Après avoir tapé ma tête contre le problème pendant un moment, cherchant un moyen de faire coexister Assembly et C / C ++, j'ai découvert qu'il s'agissait de la documentation de l'assembleur GNU:

Pour être compatibles avec les anciens assembleurs, les lignes commençant par «#» ont une interprétation particulière. Suivre le '#' devrait être une expression absolue (voir Expressions): le numéro de ligne logique de la ligne suivante. Ensuite, une chaîne (voir Chaînes) est autorisée: le cas échéant, il s'agit d'un nouveau nom de fichier logique. Le reste de la ligne, le cas échéant, devrait être un espace.

J'ai remarqué que cela ressemblait beaucoup à notre directive de préprocesseur pour C / C ++ dans la ligne 1 du fichier polyglot. Après quelques essais et erreurs, j’ai trouvé que #1 “bla” 1//*cela entrerait un commentaire de bloc pour Assembly uniquement.

Et ainsi un polyglotte a été fait.

Une fois les plus gros problèmes de blocage résolus, je me suis mis à jouer au golf dans cet exemple de Hello World.

.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édit de l'auteur principal

En fait, j'ai menti il ​​y a une minute, la toute première version du code d'Assembly que j'ai utilisé était en syntaxe AT & T, qui est l'une des deux branches syntaxiques d'Assembly. L'un des principaux éléments de la syntaxe d'AT & T est que ses références de registre utilisent un %préfixe, ce qui pose un problème pour le polyglotte. Cardinal utilise %comme pointeur, donc si nous en avons jeté beaucoup %, ce serait comme une deuxième réaction de fission.

L'autre branche syntaxique, qui n'utilise pas %de préfixe de registre, s'appelle la syntaxe Intel. L'exploit que nous utilisons dans le polyglotte pour dépasser la première ligne et entrer un commentaire de bloc se trouve dans l'assembleur GNU (GAS ou AS en abrégé). AS a la particularité de permettre les deux branches syntaxiques. Vous devez simplement déclarer que vous souhaitez utiliser la syntaxe Intel, ce qui se passe sur la ligne 1 du code d'assemblage.

L'assemblage utilise des registres, qui sont un petit nombre d'emplacements de mémoire situés littéralement sur le CPU pour la rapidité d'accès. Cela n’est pas propre à l’Assemblée, à part le fait que leur utilisation n’est pas soustraite aux préoccupations du développeur.

Il existe différents types de registres utilisés à des fins différentes. De Wikipedia:

• multiplier / diviser par AX, charger et stocker des chaînes

• CX count pour les opérations sur les chaînes et les décalages

• Adresse du port DX pour IN et OUT

• Registre d'index BX pour MOVE

• Le SP pointe en haut de la pile

• BP pointe vers la base du cadre de pile

• SI pointe vers une source dans les opérations de flux

• DI pointe vers une destination dans les opérations de flux

AX est utilisé dans la ligne de la fonction _start ici: mov rax, 1. L' ren raxindiquant que la mémoire est de 64 bits. Si nous échangions cela contre un e, cela indiquerait une mémoire 32 bits, ce qui est tout à fait valable pour un processeur 64 bits. Nous n'utiliserions tout simplement pas la moitié supérieure de la mémoire disponible. Pour indiquer la mémoire 16 bits, vous utilisez simplement ax, ce qui est correct pour nous car nous imprimons simplement des nombres entiers. Nous pouvons donc jouer au golf quelques octets en modifiant toutes les références de registre en 16 bits.

D'accord, toutes les références de registre pourraient ne pas tomber r. mov rsi, OFFSET FLAT:msg. Si vous connaissez Assembly, mais pas cette déclaration, c'est parce que cela était semi-unique à AS. Du moins, c’est ce que j’ai tiré de cela , ce qui m’a aidé à remonter au plus juste lea rsi,m.

Après cela, j’ai découvert par expérience que je pouvais casser _start:juste _pet couper .global _startcomplètement avec seulement un avertissement émis. Deuxièmement, a msg:été réduite à une seule variable de caractère p:. J'ai choisi pà la fois la variable chaîne et la fonction de départ pour compenser une partie de l' sassembly ajouté au profit d'Alphuck.

Ensuite, je mets en place ;pour délimiter les instructions afin de les mettre toutes sur une seule ligne. Cela vise principalement à éviter les #//points de fuite excessifs sur chaque ligne au profit de Thutu. De plus, j'ai remarqué que notre assembleur ne paraissait pas sensible à la casse. Je me suis donc limité à mettre en majuscule et en minuscule plusieurs caractères pour éviter tout déséquilibre incident.

Cela nous a conduit à:

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

Après tout cela, Japt et Underload étaient les seuls problèmes de cette réponse. Japt avait du bœuf avec l' *ajout de la ligne 1, mais cela semblait être résolu en revenant à la puts(p);ligne de la réponse C ++. J'ai fini par jeter un (dans cette ligne aussi et ensuite le fermer sur la ligne d'Octive. C'était tellement Underload cesserait de sefaulting. Un traitement similaire a été ajouté à la ligne 1 *.

Cela suffisait pour répondre aux besoins en octets de ce défi. En fait, j'ai vérifié cela en produisant cette version du polyglotte. Mais je voulais aussi essayer d'améliorer le score VIP si possible. Et comme je remplissais toutes les conditions du défi, je me sentais à l'aise pour collaborer au golf selon le code. Je me suis donc arrêté sur le chat polyglotte pour chercher de l'aide au golf.

Nous devons aller plus loin

@ ais523 a démontré une technique consistant à transmettre les instructions à l'assembleur sous forme de code machine avec cette instruction.

.text;.long 2298589328,898451655,12,178790,1018168591,84934449,12597 Le code machine est une série d'instructions numériques exécutées directement par la CPU, pouvant être représentées en décimal, hexadécimal ou octal. Pour nos besoins, la décimale est la plus courte depuis (hex prend une avance 0xà représenter). La .longdéclaration ici déclare que ce qui suit est une série d'instructions décimales en code machine.

Eh bien, j’ai aussi fouillé dans cette déclaration pendant un moment pour voir ce que l’assembleur autoriserait, et y ai apporté quelques modifications. Premièrement, j'ai constaté que je pouvais supprimer .text;tous les éléments ensemble, avec uniquement des problèmes d'avertissement, ce qui représentait une économie d'octets vendue. Puis un peu plus tard, j'ai aussi trouvé cette déclaration dans la documentation de l'AS

.long est la même chose que .int

Cool. Nous pouvons donc effectuer cette permutation contre un octet rapide. Maintenant, notre assemblage, mais en réalité un code machine, a été réduit à ceci:

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

Même si tout va bien, il est assez difficile de travailler directement avec le code machine et je voulais au moins voir comment faire toutes les traductions. Donc, idéalement, nous voudrions disséminer le code machine pour l'assembler. Le moyen le plus simple de le faire est de prendre un vidage d’objet, ce que @ ais523 a démontré pour moi avec cet extrait de code.

Voici l'extrait de code.

Et voici juste l'Assemblée.

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)

Ce lien affiche également des nombres hexadécimaux de 2 caractères à côté de chaque ligne d’assemblage. Celles-ci correspondent aux instructions décimales. Par exemple, si vous mettez 2298589328dans ce convertisseur décimal en hexadécimal, vous 8901B090revenez. Et si vous regardez bien, ce sont les 4 premières instructions hexadécimales du vidage d’objets (dans l’ordre inverse).

D'après ce que je peux dire, des ensembles de 4 nombres hexadécimaux sont toujours utilisés pour convertir en nombres décimaux. L'astuce principale en matière de sauvegarde d'octets consiste à structurer l'assemblage de manière à ce que les derniers nombres hexadécimaux de nos 4 ensembles soient 00. conduire à des zéros lorsque nous les mettons dans la .intdéclaration qui sont simplement omis.

C'est ce qui se passe dans la 12déclaration. Dans la partie hexagonale du vidage d’objets, c’est 0c 00 00 00.

C’est ce que je comprends de l’Assemblée en deux semaines. Quel cours intensif!

Incident

L’incident était une solution plus difficile dans la mise en œuvre d’assemblage plus courte, car il pesait beaucoup plus lourd sur les jetons polyglottes. Voici le rapport d'incident.

• ! en ligne 2 détokenizes !

• Le premier EAsur la ligne INTERCAL se détruit

• Le dernier espace sur l'avant-dernière ligne détokenize un jeton d'espace-espace.

• 85 sur la dernière ligne détokenizes

• Le Rdans #<R>"3"O.detokenizesR

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

• 16 à la dernière ligne se détruit

• 89 sur la dernière ligne se marque

Cardinal

Je viens de me rendre compte que j'ai modifié Cardinal et que j'ai oublié de le documenter. J'ai passé un peu de temps à chercher des moyens de sauver des octets et j'ai décidé d'apprendre Cardinal. Après un peu de temps avec la documentation, j'ai vu cette ligne.

= copie la valeur active du pointeur dans sa valeur inactive.

Ce n'était pas un tour utilisé dans le polyglotte. L'ancienne solution incluait ces instructions: `++ ~ * t

++ incréments jusqu'à 2.

~ change la pile active

* ajoute les piles.

J'ai réalisé que cela ~*pouvait être réalisé en n'utilisant que les =instructions. J'ai donc retravaillé la solution afin de supprimer certains échanges de pile inutiles et d'ajouter cette petite économie d'octet.

6. SMBF , 45 octets

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

Essayez-le en ligne

Ce programme imprime 1 en Python 3, 2 en V, 3 dans Minkolang v0.15, 4 in> <>, 5 en Python 2 et 6 en SMBF.

SMBF (aka Self-Modifying Brainfuck) utilise <++++<>.. Le pointeur est déplacé à gauche (jusqu'au dernier caractère du code source) et la cellule est incrémentée quatre fois, puis imprimée.

13. Rubis (129 octets)

#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

Veuillez noter le Esccaractère littéral sur la dernière ligne entre le jet d, comme indiqué dans la réponse de ais523 au Perl.

Essayez-le en ligne!

Ceci 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 rétine, 9 en Perl, 10 en Befunge, 11 en Befunge- 98, 12 dans la fission et 13 dans le rubis.

Juste une modification mineure à la printdéclaration existante d'abuser du fait que 0Ruby est véridique. J'ai dû ajouter des espaces aux autres instructions pour que l'analyse soit correcte.

15. Botte de foin (141 octets)

#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

Note: il y a un ESCaprès odans la troisième ligne et après jdans la dernière ligne

Ceci 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 rétine, 9 en Perl, 10 en Befunge, 11 en Befunge- 98 , 12 en fission, 13 en rubis, 14 en tortue et 15 en botte de foin.

Essayez-le en ligne!

Explication

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

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

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

Il y a un caractère ESC littéral dans le code actuel entre jet d; il a été remplacé par un ici pour plus de visibilité.

Ceci affiche 1 en Python 3 , 2 en Vim (testé localement, mais voici un lien pour le langage très similaire V), 3 en Minkolang , 4 en <> < , 5 en Python 2 , 6 en SMBF , 7 en Japt , 8 dans la rétine et 9 dans le Perl .

Intégrons des langages plus exotériques, en abusant d'une arithmétique qui fonctionne différemment selon les langues. ( Noneest falsey en Python mais vérité en Perl et and/ orchains fonctionnent de la même manière dans les deux langues.)

En dehors de Python, je devais aussi changer le code vim. Au lieu d'en faire une série de no-ops, je le laisse simplement insérer des fichiers indésirables, puis à nouveau les supprimer à la fin.

36. Labyrinthe , 647 octets

#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

␉est un onglet littéral, ␛un caractère ESC littéral; Stack Exchange modifierait le programme autrement. Je vous recommande de copier le programme à partir de la zone "entrée" du lien TIO ci-dessous, si vous souhaitez y travailler.

Essayez-les en ligne!

Fatigué

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

Vérification

La plupart des langues sont testées par le pilote de test illustré ci-dessus. Vous pouvez tester Reng ici et SNUSP modulaire ici ; ils ont sorti 19 et 31 respectivement. @ ais523 a aidé à déboguer et à corriger le code d'incident, qui fonctionne maintenant.

Comment fonctionne le labyrinthe

Labyrinth commence à décaler un peu les colonnes de la source, mais après quelques étapes, le pointeur se trouve à l'endroit où se Ntrouve la 2e ligne (initialement, au moment où le pointeur s'y rend, il n'est plus Nlà) , avec un 0 en haut de la pile. Ensuite, il suffit de pousser et imprimer un 36 et se termine par36!@

Choses que j'ai faites

Je savais que je voulais ajouter Labyrinth, car c'est l'un des rares esolangs que je connais un peu. Avec son débogueur, j'ai constaté qu'en changeant le 8 de la dernière ligne en un 0, Labyrinth ne restait pas coincé dans une boucle infinie et, curieusement, rien d'autre ne semblait se rompre. À partir de là, je viens de vider la commande de sortie brute et de sortie dont j'avais besoin, et celles-ci conduisaient commodément à @mettre fin aux choses.

Ensuite, il fallait réparer ce que j’avais cassé: Minkolang, Cardinal et Hexagony.

La !formulaient Minko sauter le caractère suivant, dont il avait besoin de mettre fin, donc je vient d' ajouter un supplément @. Jusqu'ici tout va bien.

Le changement de longueur de la 2ème ligne a fait manquer à Cardinal son énoncé de sortie. Essayer d'ajouter un extra .sur la première ligne a fait perdre l'esprit à Prelude (je ne sais pas pourquoi, honnêtement), alors j'ai choisi une méthode différente et je l'ai simplement abandonnée à la deuxième ligne. Cela a engendré par inadvertance un 3ème pointeur Cardinal, alors j'ai rembourré les choses avec un ?(pas un choix nécessaire, juste la première chose que j'ai trouvée qui corrige à la fois la fission et le cardinal).

Hexagony était heureusement une solution relativement simple, je viens de jeter une chaîne de lettres pour que le pointeur trouve le code. J'ai pensé que l'alphabet n'aurait pas dû apparaître avant et ne causerait pas de problèmes avec Incident. C'est aussi à ce moment que j'ai réalisé que je n'avais pas testé Incident. Grâce à @ ai523, j’ai découvert que j’avais juste besoin d’un point d’exclamation supplémentaire. La echaîne de l’alphabet a été remplacée par un !.

Les scores de L'imprimante polyvalente entière

Juste pour commenter et commenter le commentaire de @Stewie Griffin sur la question, voici un extrait qui montre le résultat de chaque réponse si elle était entrée dans "The Verstatile Integer Printer".

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

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

/* App */

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

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

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

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

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

getAnswers();

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

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

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

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

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

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

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

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

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

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

}

body { text-align: left !important}

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

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

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

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

41. brainf *** , 916 octets

#  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

␉est un onglet littéral, ␛un caractère ESC littéral; Stack Exchange modifierait le programme autrement. Je vous recommande de copier le programme à partir de la zone "entrée" du lien TIO ci-dessous, si vous souhaitez y travailler.

Essayez-le en ligne!

Score VIP (Imprimante numérique polyvalente): 0.01329

Fatigué

Ce programme 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 Incident, 32 en Whirl, 31 en SNUSP modulaire, 30 po en blanc, 29 en déclenchement, 28 en Brain-Flak, 27 en Perl 6, 26 en 05AB1E, 25 en Pip, 24 en Thutu, 23 en Hexagonie, 22 dans la sous-charge,21 en Nim, 20 en Prélude, 19 à Reng, 18 à Cardinal, 17 à Julia, 16 à Pyth, 15 à Haystack, 14 à Turtlèd, 13 à Ruby, 12 à Fission, 11 à Befunge-98, 10 à Befunge- 93, 9 en Perl 5, 8 dans la rétine, 7 à Japt, 6 en SMBF, 5 dans le python 2, 4 à> <>, 3 à Minkolang, 2 à V / vim, et 1 à 3 python.

Vérification

La plupart des langues sont testées par le pilote de test illustré ci-dessus. Vous pouvez tester Reng ici et SNUSP modulaire ici ; ils produisent respectivement 19 et 31, selon les besoins.

Le pilote de test a été mis à jour pour inclure le Tokenizer, enfin. Tout le code C est stocké en tant qu'argument du point de vue du script Bash. J'ai également modifié la sortie pour qu'elle se termine horizontalement par un espace de fin après chaque jeton au lieu de sortir verticalement. C'était juste ma préférence, pour l'adapter à la sortie de Whitespace. Mais n'importe qui d'autre peut le changer s'il sent que c'est trop déroutant.

J'ai également effectué un ajustement de testeur pour gérer l'espacement des colonnes pour le caractère UFT8 de Turtlèd dans le menu déroulant. Ce désalignement me rendait fou! Le «correctif» est plutôt compliqué, car il cherche simplement un è et modifie la largeur de la colonne pour ce cas, mais le travail est fait.

Explication

Tout d'abord, je tiens à dire à quel point l' extrait de code Rundown de l'extrait de code de la partition polyvalente de l'imprimante polyvalente de SnoringFrog était de. Cela fait un moment que je calcule les réponses avant de poster, et cela m'a inspiré à nouveau. Je pense que nous pouvons éventuellement battre la réponse de @ sp3000.

J'ai donc commencé à travailler sur cette réponse en essayant de jouer au golf avec tout ce que je pouvais et j'ai plutôt bien réussi. J'ai même eu une réponse dans une langue différente avec un nombre total d'octets inférieur à # 40. Mais alors que j'essayais de jouer à Minimal-2D, je devais apprendre le BF pour pouvoir mieux travailler avec ses dérivés et, ce faisant, j'ai trouvé le record de @ Primo Hello, World! . Je suis tombé amoureux de l'élégance.

Il s’est avéré que Minimal-2D n’était pas assez efficace pour utiliser la technique d’initialisation de la bande utilisée par @Primo, mais j’estime qu’elle serait probablement trop lourde de toute façon. Nous essayons seulement d'imprimer un entier après tout. Mais @Primo m'a effectivement envoyé sur le chemin pour apprendre à se multiplier en BF, ce que j'ai apporté au code de Minimal-2D.

Après tout cela, j'ai relu le commentaire de SnoringFrog sur la manière d'inclure BF et je me suis rendu compte que non seulement je pouvais le faire, mais que je pouvais utiliser une grande partie du code Minimal-2D que j'avais trouvé dans la réponse à BF. J'ai donc creusé pour répondre avec BF, et nous y sommes.

Une dernière chose avant d'entrer dans les détails. J'ai apporté quelques modifications pour des raisons autres que le golf. Tout d'abord, j'ai déplacé la majeure partie du code ajouté par @SnoringFrog juste en dessous des langues 2D dans les rangées supérieures. Pour moi, c'est un geste stratégique à long terme d'empêcher 2D-langs de traverser le centre du polyglotte afin d'éviter autant que possible les futurs bugs. Le nombre d'octets touchés était faible pour ce déplacement, alors je me suis lancé.

Deuxièmement, au cours des différentes ré-factorisations, j’ai appris que Begunges et Minkolang produisaient un espace après les sorties numériques, ce qui était la cause des octets nuls que nous avons vus dans Test Driver pour ces langues. J'ai corrigé ces problèmes en affichant la valeur de la pile sous forme de code ascii (qui n'incluait pas la fonctionnalité d'espace de fin), au lieu de la valeur directement. Il y avait aussi un petit octet pour ce changement, mais maintenant la sortie du pilote de test est si uniforme. Comment ne pourais-je pas?

SM / BF

Passons rapidement en revue les bases. Ce sont les seules commandes valides pour SMBF et 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

Les deux langues ont une bande mémoire où les valeurs sont stockées et modifiées. La seule différence de SMBF est que le code en cours d’exécution est également stocké sur la bande mémoire située à gauche du point de départ. Comme @SnoringFrog l'a souligné, pour obtenir des résultats différents avec SMBF et BF, il faut déplacer le pointeur de mémoire à gauche de l'origine. Dans l'interpréteur BF de Tio, le pointeur de mémoire est capable de se déplacer à gauche de l'origine et trouvera des 0 à la place des codes ascii du Polyglot que SMBF voit. Voici un exemple qui peut être exécuté à la fois en SMBF et en BF pour illustrer la différence.

Au début du polyglotte, les créations nécessitent la fin >de la deuxième ligne et Perl6 exige que chaque >soit précédé de la lettre <. Alors, SM / BF commence par <>laisser le pointeur de la mémoire à l’origine, puis frappe un [qui saute des caractères offensants pour les deux langues à ]la 6ème rangée.

Ensuite, nous incrémentons la cellule de mémoire d'origine pour les deux langues et nous déplaçons le pointeur de mémoire vers la gauche avec +<. (Par convention, nous appelons la cellule de mémoire d'origine la cellule 0, les cellules situées à droite de l'origine 1, 2, ... et les cellules situées à gauche -1, -2,…). La cellule -1 contient le code asci du dernier caractère du polyglotte dans SMBF et 0 dans BF. Ainsi, lorsque le prochain [est rencontré, seul BF passe au suivant ]tandis que SMBF passe dans le code.

Lorsque SMBF le traverse, [.>-]il affiche le 6 trouvé à la fin du polyglotte, puis ramène le pointeur de la mémoire à la cellule 0, en remettant sa valeur à zéro pour quitter le fichier ]. À noter que les cassettes à cette pinte sont les suivantes: Les cellules négatives du SMBF contiennent le polyglotte, 0 et les cellules positives le zéro. Les cellules négatives et positives de BF contiennent zéro alors que la cellule d'origine en contient 1.

Ensuite, >déplacez SMBF vers la cellule 1 et BF vers la cellule 0, permettant ainsi à BF d'entrer son bloc de code privé: [<+++++[>++++++++++<-][<<<]>+.---.>](j'en ai supprimé les caractères non-BF). Ici, nous revenons à la cellule -1 et initialisons notre variable de contrôle de boucle (cellule -1) à 5. Ensuite, nous entrons dans la boucle où nous ajoutons 10 à la cellule 0 et décrémentons la cellule -1 cinq fois avant de quitter la boucle où nous allons pointer sur la cellule -1 avec la valeur 0.

Ensuite nous rencontrons [<<<]en pointant à zéro, donc BF ne passe pas par là. Le but ici est d’équilibrer un nombre de >'s avec des précédents <pour que Perl6 ne s’échappe pas.

À ce stade, la cellule 0 a une valeur de 51. La valeur ascii de 4 est 52, nous déplaçons donc le pointeur vers la cellule 0, ajoutons 1, puis imprimons la valeur. Enfin, nous décrémentons la cellule 0 sur le caractère ascii 1 et imprimons à nouveau avant de placer le pointeur de la mémoire sur la cellule 1 (valeur 0) pour sortir après le ].

SMBF et BF touchent tous les deux la dernière [ligne 8 alors que les deux reposent sur une valeur 0. Ainsi, les deux sautent devant le code Minimal-2D restant jusqu'à ce que ]soit rencontrée sur la ligne 11. Mais sa durée est courte car la ligne 12 commence par une autre [qui place les deux langues presque à la fin du polyglotte où aucune autre instruction n'est rencontrée.

Refactors

Minimal 2D

La réécriture de Minimal-2D visait principalement à sauvegarder des octets de manière similaire à la technique de multiplication de BF. Minimal-2D n'a cependant pas les caractères [et ]pour le contrôle de boucle. Au lieu de cela, il a ces commandes:

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

Celles-ci peuvent être utilisées pour produire la même structure logique, bien que de manière 2D, que celle de BF. Par exemple, BF ++++++[>++++++<-]>.équivaut à ceci en Minimal-2D.

Voici une version simplifiée du code de Minimal-2D dans le polyglot, avec tout le code étranger supprimé et tous les caractères de substitution remplacés par #.

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

La Dligne 1 envoie le pointeur d’instruction à la Lligne 8 du polyglotte qui envoie le pointeur à gauche. Ici, nous définissons la variable de contrôle de boucle (cellule 0) sur 7, déplaçons le pointeur de la mémoire vers la cellule 1 et entrons une boucle. En boucle, nous ajoutons 3 à la cellule 1, décrémentons la cellule 0 puis vérifions si la valeur de la cellule 0 est encore nulle. Sinon, nous ajoutons un autre 8 à la cellule 1, puis décrémentons et vérifions à nouveau. Le résultat de cette boucle est que la cellule 1 a la valeur 51 à la fin de la boucle (6 * 8 + 3).

Nous quittons la boucle en sautant Udessus, en déplaçant le pointeur de mémoire dans la cellule 1 et en descendant puis à droite sur la ligne 11 du polyglotte. Et enfin, nous incrémentons jusqu'à la valeur ascii pour 4 puis décrémentons jusqu'à la valeur ascii pour 0 avant de partir à droite pour mettre fin au programme.

Rétine

Retina avait de nombreuses exigences avec lesquelles il était difficile de travailler pour tous les dérivés de la BF. Il n'aime pas les consécutives +ou ne correspond pas ()ou []. Mais ce ne sont en réalité que des exigences pour toutes les autres lignes. Une grande partie du travail effectué pour BF, SMBF et Minimal-2D consistait donc à placer la majeure partie du code sur des lignes paires.

Le seul octet réservé uniquement à Retina est celui situé |à la fin de la ligne 11. Pour citer @ ais523, «la plupart des expressions rationnelles se terminant par | correspondra à rien ". Sans cela, Retina renvoie 0. Pourquoi cela résout-il le problème, je ne le sais pas. Je n'ai pas trop eu à fouiller dans Retina, probablement parce que j'ai évité la longue file. Mais comme Prelude, j'ai constaté que je n'avais pas besoin de le comprendre autant que de savoir comment le déboguer, qui consistait principalement en la suppression de lignes (par multiples de 2) jusqu'à ce que j'ai trouvé la ligne. cela provoque sa rupture. J'ai deviné à ce correctif basé sur le commentaire de @ ais523, et a été récompensé. Je suis trop cool pour l'école, je suppose.

Cardinal

Il m'est arrivé d'aimer le placement de Minimal-2D par @ SnoringFrog par rapport au code de Cardinal. C'est un bon emplacement, car Cardinal ne contrarie pas Retina et semble permettre une imbrication avec Minimal-2D. Ainsi, lorsque je me suis mis en route pour transplanter les versions Minimal 2D et 2D, j'ai accompagné Cardinal. Cependant, Cardinal a subi quelques changements cosmétiques. Premièrement, j'ai jeté un >début proche de sa déclaration #p x%>~~~+ +~*ttt*.xpour Minimal-2D pour changer les pointeurs de mémoire dans sa boucle / Deuxièmement, j'ai tout déplacé d'un caractère à la droite pour donner à Minimal-2D l'espace nécessaire pour sortir de sa boucle gracieusement. Le pdans cette aiguille est pour ce remplissage de caractère.

Befunge / 98

C'est en fait à Befunges que j'ai commencé à essayer de jouer au polyglotte, car le refactor C ++ a modifié tous les autres codes de langage 2D, à l'exception de celui-ci. En essayant d'apprendre que WTF se passait dans ce code, j'ai trouvé ceci dans la documentation de Begunge:

La .commande extraira une valeur de la pile et la affichera sous la forme d'un entier décimal, suivi d'un espace , un peu comme Forth. ,affichera une valeur, l'interprétera comme la valeur ASCII d'un caractère et affichera ce caractère ( non suivi d'un espace ) .

Bonté divine! Nous pouvons nettoyer les octets nuls sur la sortie. Après cela, il ne restait plus qu'à trouver comment entrer les valeurs asci les plus grandes et à séparer le code. Befunge-98 avait un code de saut ;disant de sauter par- dessus l' [77*,68*,@en ;[77*,68*,@;'1,'1,q, qui nous a donné la ségrégation.

Befunge-98 avait aussi une commande ( ') pour prendre le code ASCII du caractère suivant. Donc, '1,prend le code code asci pour le caractère 1, le place sur la pile, puis affiche le caractère asci pour la valeur supérieure de la pile avec ,. Je dois juste faire ceci deux fois pour imprimer 11 et lâcher un qpour quitter gracieusement.

Befunge proprement dit est un peu moins pratique, mais juste. Ici, nous devons effectuer un calcul pour mettre le code souhaité sur la pile. Heureusement, nos codes ont été facilement multipliés avec 7 * 7 et 6 * 8 avant la même commande de sortie ,. Nous avons ensuite quitté Befunge @avant que le code de son frère aîné ne contamine la sortie.

Minkolang

Après avoir trouvé un correctif pour les espaces de fin du Befunge, je me suis énervé sur l'idée de trouver un correctif pour Minkolang également. La documentation de Minkolang indiquait que la commande de sortie utilisée jusque-là fonctionnait de la même manière que l'interpréteur Befunge. OIl se trouve qu’il s’agissait d’une autre commande de sortie, qui n’était pas décrite comme partageant cette attitude, alors j’ai pris une photo dans le noir et essayé d’afficher la chaîne "3". Victoire sans faille.

> <>

L'une des premières choses que j'ai regardées lorsque j'ai déplacé le code Minimal-2D était de vérifier que je pouvais le déplacer> <> avec lui. Si je devais gérer le transversalisme 2D polyglotte, j'allais traiter de toutes les transgressions. En gros, la chance m'a poussé dans la solution consistant ;n4 à mettre à la fin de la ligne 1 et à \Dreculer de la ligne 1. En passant, je ne savais pas que> <> pourrait être redirigé avant la réponse 40 car elle a été si bien contenue . J'aimerais penser que cela pourrait être utilisé plus tard pour diverger> <> d'un autre langage similaire.

Perl6

J'ai déjà évoqué certains des <>problèmes d'équilibrage de Perl6 ailleurs dans cette réponse, je ne vais donc pas y revenir. Mais je tiens à souligner que je suis passé #>27.say#à l'avant-dernière ligne. Cela n'a pas d'objet fonctionnel dans cette réponse. En fait, j'ai pris cette décision pour satisfaire une réponse différente, à savoir que je n'avais pas utilisé ce tour. J'ai décidé de simplement laisser tomber car je prévois de poster cette réponse à ma prochaine occasion et je ne voulais pas prendre la peine de la défaire et de la refaire.

Corrections de bugs

05as1e

05as1e n’a définitivement pas aimé le nouveau code Begunge autant que l’ancienne version. Je suppose que c'est le ,s puisque c'est le seul personnage révolutionnaire. En tout état de cause, je devais reculer de la "ligne deux pour masquer les commandes offensives, et je savais qu'il "fallait y aller avant le chemin du code Befunge, car "c'était un oui dans les deux langues. (Je peux juste inventer des termes comme yes-op right?) La <bidimensionnalité de Line 2 est assez rigide, mais j’ai pu déplacer l’ ancien chemin de code de Begunge avec le ". L' <cependant était une exigence de Perl6. (Il doit y avoir un <précédent avant tout >.) J'ai été capable de déposer la première <ligne à un endroit deviné par instinct et par avance, résolvant 05ab1e et le désaccord de Perl6.

Tourbillon

Les changements de Befunge sur la ligne 2 ont ajouté un supplément 1au polyglotte avant la ligne Incident / Whirl. Cela a 1amené Whirl à indiquer les mauvaises instructions sur le volant. La toute première 1directive du préprocesseur du C / C ++ était uniquement une référence de numéro de ligne dans le code, et il pouvait tout aussi bien s'agir de tout autre numéro de ligne. J'ai donc modifié ce 4paramètre de manière arbitraire afin de satisfaire Whirl.

Incident

La chaîne de détokenizing à la fin du polyglotte est bien connue à ce stade, donc je ne vais pas y entrer. J'ai retiré de la chaîne ce que je pouvais et ajouté les nouveaux jetons requis. Il y a 2 caractères détokenizing qui ne sont pas dans cette chaîne, mais que je devrais signaler. Tout d' abord, le deuxième Ren #R+.----.R >]|est nécessaire ici parce que c'est un point de départ de Fusion, et il était plus sûr sur cette ligne parce qu'il y avait déjà un titre de point de départ de Fusion dans la même direction. Deuxièmement, l' xen #= xconsiste à supprimer un jeton impliqué dans un ␉␊#modèle, qui est devenu plus courant.

Autres

Hexagony, Whitespace et Prelude ont tous eu les ajustements mineurs habituels, mais rien d’autre ne mérite d’être évoqués.

Dernières pensées

C'est tout ce que j'ai pour cette réponse. Pour ceux qui recherchent un point de départ pour la réponse suivante, je suggérerais le mal. Cela semble fonctionner, même si je ne l'ai pas trop regardé de près, mais je suppose que cela ne serait pas trop difficile à intégrer. Je sais qu'il a une commande de saut qui devrait aider à passer au-delà du gros du polyglotte. Bonne chance.

183. Image de démarrage Intel 8080 (ZEMU), 9870 octets

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

Essayez-le en ligne!

Explication

Merci à Potato44 pour l’idée d’ajouter du code machine, c’était très amusant de répondre à cette question.

Je n'ai pas fait de fichier COM CP / M car il limite la taille des polyglottes à environ 60 Ko, ce que je veux éviter. L’image de démarrage s’est avérée encore plus facile à faire que COM, car ZEMU charge le secteur de démarrage à partir du 6ème secteur par défaut (secteurs logiques basés sur 1, 128 octets); Le code de démarrage doit être au décalage 0x280 ((6-1) * 128) dans le polyglot.

J'utilise Zemu émulateur qui est lié de cette page . Pour exécuter polyglotte dans ZEMU:

• Disques> A: sélection du fichier polyglotte
• Options> Jeu d'instructions I8080
• Appuyez sur le bouton de démarrage

La fonction imprimant un caractère sur console ( cns$ot) a été copiée à partir de BIOS22Dv221.ASM à partir de la distribution ZEMU. J'ai apporté deux modifications: le caractère n'est pas masqué en ASCII 7 bits car nous contrôlons les paramètres et jrz cns$otest remplacé par jz cns$otcar jrz(saut relatif si zéro) est une instruction Zilog Z80 non présente dans Intel 8080.

Programme initial ( syntaxe Intel , assembleur lié à partir d' ici ):

    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

Ce programme contient des caractères qui ne peuvent pas être utilisés directement en polyglotte. La plupart des caractères de contrôle ASCII (code <0x20) sont interdits dans Simula, les caractères non-ASCII (code> = 0x80) ne peuvent pas apparaître seuls car le fichier doit être valide UTF-8. Donc, le programme ci-dessus est généré par un autre programme qui est valide UTF-8.

Le programme suivant génère le code nécessaire et y accède. ld (hl),ane peut pas être utilisé à cause de Grass ( 'w'==0x77). sub h(0x94) et xor a(0xAF) sont des octets de continuation UTF-8, ils doivent être précédés de l'octet UTF-8. L'instruction ret nc(= 0xD0, return si non carry) est utilisée comme octet UTF-8 principal. Pour ne rien faire, il est précédé d'une scfinstruction (set carry flag). Également évité ','(0x2C) et '.'(0x2E) pour DOBELA. org 0100hLa directive n'est pas utilisée car l'assembleur utilisé ne la comprend pas (l'organisation est définie dans l'interface graphique). Ce programme est indépendant de toute façon. J'aime plus les mnémoniques Zilog, je les ai donc utilisées pour un programme plus long.

Syntaxe Zilog , assembleur lié à partir d' ici :

  ; 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

Ce programme est assemblé 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退

Il doit être au décalage 0x280 dans le polyglotte (voir ligne 2). Le test d'abstraction dans le pilote de test vérifie cela.

Refactorings

Coquilles

Les coquilles déplacées revenaient à la plus longue ligne. J'aime plus cette mise en page car les parens ne sont pas alignés avec les autres langs. Les Moorhenses et les Flaks ont été déplacés avant les obus afin qu'ils ne se cassent pas lorsque les obus sont changés. La plus longue ligne a maintenant cette disposition:

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

Nouveau code shell:

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

Vieux code coquilles:

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 longueur de $aest calculée $(echo -n $a | wc -c)maintenant (à partir d' ici ). Au départ, je l’utilisais pour m'en débarrasser #, mais maintenant, c'est parce que le code est plus court. Les coquilles peuvent contenir #parce que les Flaks sont avant les coquilles.

Yash (166) utilise la commande echo intégrée qui ne prend pas en charge les options par défaut. Par conséquent, "-n" et un saut de ligne font partie de la sortie, ce qui donne 4 octets supplémentaires. Lorsque non défini, la valeur par ECHO_STYLEdéfaut est SYSV(l' -noption n'est pas acceptée).

Ce lien TIO teste le code dans tous les shells.

Additionnel ((((( avant les obus corrigent Underload et Retina. Une autre paire de parens est ajoutée pour masquer 58Prelude (fermé avec #)après exit). {avant ((((((est pour Japt, sans cela, Japt se bloque.

Flaks

En raison de la relocalisation des Flaks, le code de départ peut être simplifié - il ne ([])reste que:

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

Ce lien TIO teste le code dans toutes les Flaks.

Fission et cardinal

Fission a été déplacé dans LNUSP: R"12"R _*. Le deuxième pointeur est utilisé pour terminer la fission le plus rapidement possible - à la 3e étape, voir réponse à la question 54 pour plus d'informations.

Cardinal a été transféré au LNUSP: @ %"18" . Comme dans la fission, le deuxième pointeur est utilisé pour terminer Cardinal dès que possible - à la troisième étape.

MarioLANG

Utilisez ####...au lieu de ====...comme une plate-forme:

Minimal 2D

Polyglotte avec MarioLANG:

Wierd & 1L_a

Wierd: utilisez un espace à la ligne 10 de la colonne 79 pour refléter IP.
1L_a, Wierd: l'espace à la ligne 9 de la colonne 79 est important.

Cubiquement

Nouveau code: :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

Nouveau code: !|*****[[[828+*+@+*99]]]*****|!

Après tout, la pile de multiplications contient un seul zéro parce que sauter de la pile vide donne zéro. Ce zéro est ajouté au nombre principal avec à +côté de @. Auparavant, il était jeté avec ?, voir la réponse Klein 001 .

Comment fonctionnent les portes à Klein:

Tourbillon

Le code Whirl est fondamentalement identique, le seul changement est que le code principal suppose que l'opération en cours est ops.one (2), pas ops.load (4).

Whirl peut être considéré comme ayant 3 opérations:

• 1 faire une rotation
• 0 commutateur sens de rotation
• 00 exécuter l'instruction en cours et changer de sonnerie

Opérations combinées pour simplifier le raisonnement sur le programme:

• 0000 si l'opération actuelle de l'anneau inactif est noop, il suffit d'exécuter l'opération actuelle de l'anneau actif sans aucun effet secondaire
• 11..11 faire pivoter n étapes
• 011..11 changer de direction et faire pivoter n étapes

0000exécute l'instruction en cours de la sonnerie active, mais exécute également l'instruction en cours de la sonnerie inactive en tant qu'effet secondaire. Si les instructions actuelles concernant la sonnerie inactive sont sans danger, nous pouvons simplement nous concentrer sur les opérations relatives à la sonnerie active sans penser à ce qui se passe avec la sonnerie inactive. Ceci est particulièrement utile avec ce programme car il est clairement séparé: tout d’abord, le numéro 32 est créé en utilisant uniquement un anneau mathématique, puis nous basculons sur ops ring et y exécutons 2 instructions (print et exit).

Premièrement, je voulais que l'opération en cours sur la sonnerie ops soit noop lorsque l'exécution du code principal a commencé. Il présente 2 avantages: 1) le code principal Whirl peut être exécuté de manière autonome et 2) nous pouvons complètement oublier la sonnerie ops lors de la création du numéro 32 avec une bague mathématique. Cependant, le code étant plus long qu'il ne l'était, le code principal suppose donc que l'opération en cours est ops.one (2). Cela signifie que ops.value est défini sur 1 en tant qu'effet secondaire des opérations mathématiques, qui est ensuite utilisé pour l'impression. L'ancien code produisait le même effet avec l'instruction ops.load, mais l'utilisation de ops.one exprimait plus clairement l'intention: définir ops.value sur une valeur non nulle.

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

Le nouveau code est plus court car l’ancien code comporte deux commutateurs de direction redondants dans la deuxième partie du programme, et non à cause d’une nouvelle hypothèse.

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

Comment garder Whirl correct en changeant quelque chose avant la ligne Incident / Whirl:

• s'assurer qu'il y a un nombre pair de 0s avant le code Whirl principal
• s'assurer qu'il n'y a pas deux 0s consécutifs
• ajouter / supprimer suffisamment de 1s jusqu'à ce que Whirl fonctionne à nouveau; ajouter n 1s équivaut à supprimer 12-n 1s et inversement

J'ai inconsciemment enfreint la première règle lorsque j'ai ajouté Ropy. Lorsqu'il y a un nombre impair de 0s, le code principal commence à s'exécuter avec une direction incorrecte de la sonnerie ops qui interrompt l'instruction de sortie. Donc maintenant il y a la 0ligne 3 qui compense la 0ligne 1.

Autres

CoffeeScript : console.log a&&39||180(à partir d' ici )

INTERCAL : déplacé vers la ligne 37
Brainfuck , Agony : déplacé vers d'autres dérivés de brainfuck sur la ligne 10

xEec : déplacé dans 1L_a ( h#115# o#)

CSL : déplacé vers la ligne 80
Trefunge : déplacé vers la ligne 120
Gaot ++ , Stones : placé sur des lignes séparées

16. Pyth (159 octets)

#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

Remarque: il y a un ESCbyte ( 0x1B) après le odans la troisième ligne et après lej dans la dernière ligne.

C'était une expérience assez amusante. Japt et Pyth sont tous deux des langues de golf, mais Japt est un infixe et Pyth est un préfixe. Pyth demande automatiquement les entrées et échoue si des arguments sont manquants.

Avant la réponse de Haystack, je disposais d'une solution presque efficace #, qui obtenait un code de caractère dans Japt et une boucle jusqu'à l'erreur en Pyth. Pyth s'avère être très utile dans les polyglottes, car le caractère de commentaire commun #fonctionne essentiellement comme un silencieux d'erreur.

Quand je suis rentré à la maison, j'ai réussi à trouver un morceau de code qui fonctionnait à la fois en utilisant //, qui fonctionne comme un commentaire dans Japt et deux divisions en Pyth. Ensuite, il s’agissait simplement d’obtenir le bon acheminement des Befunges.

Il est très peu probable que ce soit optimal, mais c'est assez bon pour l'instant. J'ai essayé de tous les tester, mais j'apprécierais beaucoup que quelqu'un vérifie que les sorties correspondent.

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

16 en Pyth .

Explication

Ce que Pyth voit ici est:

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

Cela se traduit par le pseudocode suivant:

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"

La première boucle se termine lorsque vous essayez d'évaluer ;ce qui n'est pas une expression valide. Ensuite, Pyth imprime simplement 16.