Questa è una sfida incatenata alla risposta in cui ogni risposta si basa sulla risposta precedente. Raccomando di ordinare il thread in base a "più vecchio" per essere sicuri dell'ordine in cui vengono pubblicati i post.

Nota : questa è diventata una sfida piuttosto duratura e pubblicare nuove risposte è abbastanza difficile. In quanto tale, ora è disponibile una chat room per questa sfida, nel caso in cui desideri consigli su una parte specifica di una potenziale risposta, avere idee per le lingue che potrebbero essere aggiunte o simili. Sentiti libero di entrare se hai qualcosa da chiedere o da dire!

L'obiettivo

Il n ° programma da presentare deve essere eseguito in n lingue diverse; in particolare, tutte le lingue aggiunte nei programmi precedenti da presentare, più un'altra. Il programma deve generare 1 quando viene eseguito nella prima lingua utilizzata nelle risposte a questa domanda, 2 quando viene eseguito nella seconda lingua e così via. Ad esempio, la prima risposta potrebbe stampare 1 quando eseguita in Python 3 e la seconda risposta potrebbe generare 1 quando eseguita in Python 3 e 2 quando eseguita in JavaScript; in questo caso, la terza risposta dovrebbe produrre 1 quando viene eseguito in Python 3, 2 quando viene eseguito in JavaScript e 3 quando viene eseguito in un'altra lingua.

Regole aggiuntive

• Il programma deve essere eseguito senza errori o arresti anomali. Gli avvisi (e altri output stderr) sono accettabili, ma il programma deve uscire normalmente (ad es. Eseguendo la fine del programma o tramite un comando come quello exitche esegue la normale conclusione del programma).

• L'output deve essere solo il numero intero, ma le nuove righe finali sono OK. Sono consentiti anche altri output stdout inevitabili. Esempi: nome e versione dell'interprete in Befunge-93, spazio dopo stringa stampata in Zephyr. Alcuni linguaggi offrono due metodi di stampa: con e senza spazio finale; in questo caso è necessario utilizzare il metodo senza spazio finale.

• Ogni risposta non deve essere più lunga del 20% o 20 byte (a seconda di quale sia più grande) della risposta precedente. (Questo serve a prevenire l'uso di lingue come Lenguage come spamming e incoraggiare almeno una piccola parte del golf.)

• È consentito utilizzare versioni diverse della stessa lingua (anche se ovviamente dovranno stampare numeri diversi, quindi dovrai inserire un controllo di versione nel poliglotta). Tuttavia, non è possibile utilizzare una funzione di lingua che restituisce il numero di versione della lingua. Ripetere esattamente la stessa lingua è, ovviamente, impossibile (poiché il programma dovrebbe stampare in modo deterministico uno di due numeri diversi).
• Trucchi come l'abuso eccessivo di commenti, nonostante siano stati banditi in alcune competizioni poliglotta, qui vanno bene.
• Non è necessario utilizzare le risposte precedenti come guida per scrivere le proprie (è possibile riscrivere l'intero programma, se lo si desidera, purché conforme alle specifiche); tuttavia, è consentito basare la risposta principalmente su una risposta precedente e probabilmente il modo più semplice per trovare una soluzione.
• Non è possibile inviare due risposte di seguito. Consenti a qualcun altro di postare tra. Questa regola si applica fino al raggiungimento della condizione di vittoria.
• Poiché questa sfida richiede ad altri concorrenti di pubblicare nelle stesse lingue in cui ti trovi, puoi utilizzare solo le lingue con un'implementazione gratuita (come se si trattasse di un concorso di poliziotti e ladri ).
• Nel caso in cui una lingua abbia più di un interprete, è possibile scegliere qualsiasi interprete per una determinata lingua purché tutti i programmi che devono funzionare correttamente in quella lingua lo facciano in quell'interprete. (In altre parole, se un programma funziona in più di un interprete, i post futuri possono scegliere uno di questi interpreti, piuttosto che un post che "blocca" una particolare scelta di interprete per una lingua.)
• Questa sfida ora utilizza le nuove regole PPCG sulla scelta della lingua : puoi usare una lingua o un interprete linguistico, anche se è più recente della domanda. Tuttavia, non è possibile utilizzare una lingua / interprete più recente della domanda se a) la lingua è stata progettata allo scopo di poliglottazione o b) la lingua è stata ispirata da questa domanda. (Quindi i linguaggi di programmazione pratica di nuova concezione saranno quasi sicuramente OK, così come gli esolang non correlati, ma cose come A Pear Tree , che è stato ispirato da questa domanda, sono vietate.) Nota che questo non cambia la validità dei linguaggi progettati per poliglottare che sono più vecchi di questa domanda.
• Nota che la condizione di vittoria (vedi sotto) è progettata in modo tale che spezzare la catena (cioè rendere impossibile a chiunque altro rispondere dopo di te tramite l'uso di una lingua che è difficile poliglottare con altre lingue) ti squalificherà dal vincere. L'obiettivo è di continuare il più a lungo possibile e, se vuoi vincere, dovrai rispettarlo.

Formato di risposta

Poiché tutte le risposte dipendono l'una dall'altra, avere un formato di risposta coerente sarà utile. Ti consiglio di formattare la tua risposta in questo modo (questo è un esempio per il secondo link della catena):

2. JavaScript, 40 byte

(program goes here)

Questo programma stampa 1 in Python 3 e 2 in JavaScript.

(se vuoi spiegare il programma, le tecniche di poliglotta, ecc., inseriscili qui)

Condizione di vittoria

Una volta che non ci sono state nuove risposte per 14 giorni, il vincitore sarà chiunque abbia pubblicato la seconda risposta più recente, ovvero il più grande poliglotta che è stato dimostrato di non aver rotto la catena. Tuttavia, l'estensione della catena è ancora molto gradita!

Il vincitore è Chance , vedi risposta 194 (TemplAt) .

Elenco delle lingue

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

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

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

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

var answers = [], answer_page = 1;

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

getAnswers();

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

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

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


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Nota: se lo vedi per primo, potresti ordinare in base al più vecchio

17. Julia (128 byte)

#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

Ci sono due ESC sull'ultima riga, uno prima del primo ge uno dopo il 2. Questo potrebbe essere golfato di più, ma le cose sono diventate disordinate no grazie a V e Pyth.

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

suggerimenti:

• L'inizio della quarta riga è Python 2/3, Perl, Ruby. La fine è Julia, grazie ai #=commenti multilinea (nota che Julia non ha and/or).
• V è <ESC>gg99ddi2<ESC>, che è sicuramente giocabile a golf ma V è fastidioso provare su Provalo online! poiché l'interprete è abbastanza lento.
• Minkolang e Haystack scendono alla prima v. Befunge-93 e -98 no, e dipendono da a b.
• Retina conta il numero di spazi e 1 nella quarta riga e V si nasconde nella configurazione per Retina (cioè prima del backtick).
• Per il suggerimento di @ ETHproduzione, Japt usa i backtick per nascondere la maggior parte del codice in una stringa.
• La fissione è R"12"*.
• SMBF ha giocato a golf <.in prima linea, oltre alla finale 6.

23. Esagonia , 186 byte

Scusate se questo incasina i piani ...

#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

␛ è usato per rappresentare un carattere letterale ESC.

stampe:

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

Per accedere alle lingue non collegate, fai clic sul change languagepulsante in alto a destra nel collegamento Esagonia.

L'esagonia non è leggibile (affatto) in questo formato. Dobbiamo guardarlo in forma esagonale.
Nota che i 2 caratteri ESC sono stati sostituiti con ␛s in modo da poterli vedere - sono ignorati, quindi non ce ne sono altri nel programma:

        # 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

Per coloro che non hanno familiarità con Hexagony , ci sono 6 IP, che iniziano ai 6 angoli. È attivo solo 1 alla volta e si passa usando #][. Il modello di memoria non è così importante per questo programma, ma potrebbe essere necessario per capirlo in futuro. Tutto quello che devi sapere è che 1 int è memorizzato in un "bordo di memoria" (in breve ME), e '"}{cambia il ME che è attivo.

\/|_>< sono mirror che controllano il flusso del programma.

È così che funziona:

Prima riga eseguita:

#       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

Il fondo (snippet ruotato verticalmente in modo da poter leggere verso il basso):

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

Il bordo destro:

        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 !

L'ultimo bit di codice pertinente:

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

Cose da notare:

• Hexagony elimina tutti i se `prima dell'esecuzione, quindi qualsiasi modifica a questi non influirà su Hexagony
• Avevo bisogno di riempire il codice in modo che potesse essere interpretato come un esagono di 9 lunghezze, anziché come un ottavo - fai attenzione a giocare a golf sotto 169 o sopra 217 caratteri pertinenti
• Per questo motivo , i ~~~e i 2 0alla fine possono essere modificati senza danneggiare il codice
• Il =""giusto sposta il ME lontano dal precedente in modo che un nuovo ME possa essere modificato. Possono essere sostituiti con altri personaggi che fanno la stessa cosa senza danneggiare il programma esagonico ( 'i, per esempio)
• Questo non è tecnicamente compatibile con le specifiche di Befunge 93, perché limita il riquadro di delimitazione del codice a 80 per 25 caratteri. Tuttavia, la maggior parte degli interferometri ignora questa specifica (come TIO), quindi non penso personalmente che sia un grosso problema. Se lo fai, sentiti libero di lasciare un commento. (Se abbastanza vuoi davvero che lo cambi, allora proverò)
• Spero non sia troppo difficile ora.

50. bash, 1024 byte

#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

Vuoi saperne di più? Prova la chat di Polygot !

Provali online!

Come al solito, ho sostituito le schede letterali con ␉e caratteri letterali ESC con ␛, a causa delle limitazioni di Stack Exchange. Puoi ottenere una versione facilmente copiabile del programma dalla casella "input" del link TIO sopra.

Corri giù

Questo programma stampa 50 in bash, 49 in Octave, 48 in Deadfish ~, 47 in Lily, 46 in Cubix, 45 in PicoLisp, 44 in alphuck, 43 in reticolare, 42 in male, 41 in cervello ***, 40 in minimo -2D, 39 in CoffeeScript, 38 in C, 37 in C ++, 36 in Labyrinth, 35 in INTERCAL, 34 in Rail, 33 in Incident, 32 in Whirl, 31 in SNUSP modulare, 30 in Whitespace, 29 in Trigger, 28 in Brain-Flak, 27 in Perl 6, in Ruby, 12 in Fission, 11 in Befunge-98, 10 in Befunge-93,26 in 05AB1E, 25 in Pip, 24 in Thutu, 23 in Esagonia, 22 in Sottocarico, 21 in Nim, 20 in Preludio, 19 in Reng, 18 in Cardinale, 17 in Julia, 16 in Pyth, 15 in Haystack, 14 in Turtlèd, 139 in Perl 5,8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in> <>, 3 in Minkolang, 2 in V / Vim e 1 in Python 3.

Verifica

La maggior parte delle lingue sono testate dal driver di test sopra. I soliti quattro colpevoli devono essere testati separatamente:

• L'incidente è stato testato usando il suo interprete ufficiale, offline;

• Deadfish ~ è stato anche testato usando il suo interprete ufficiale, offline;

• SNUSP modulare è stato testato online qui ;

• Reng è stato testato online qui .

Spiegazione

Stavo cercando vari lead per le lingue da aggiungere. Una possibilità era trovare un linguaggio con #commenti di riga che potesse essere plausibilmente aggiunto alla riga "linguaggio di scripting" (che gestisce Perl, Python 2 e 3 e Ruby). Mi ci è voluto un po 'di tempo per pensare a un linguaggio appropriato che potesse essere compatibile con la sintassi con quelli già presenti, però.

Si scopre che la risposta mi ha fissato in faccia per anni. Se si fa clic sul collegamento TIO sopra, si aprirà il driver di test poliglotta, che è scritto in bash. Quindi per tutto questo tempo, ho avuto una scheda che diceva "Bash - TIO Nexus". Avresti pensato che sarebbe stato un indizio, ma a quanto pare l'ho perso. Come bonus, bash è anche un linguaggio di scripting, quindi il termine "linea di linguaggio di scripting" è ancora appropriato.

Il programma bash inizia nello stesso posto degli altri linguaggi di scripting. Tuttavia, c'è un modo abbastanza semplice per separarlo da loro; nelle stringhe a virgoletta singola, \è un carattere di escape nella maggior parte delle lingue, ma non in bash. Quindi possiamo nascondere il codice bash dalle altre lingue tramite '\'…';, che è un'istruzione degenerata (senza alcun effetto) in Perl, Python e Ruby, ma eseguita in bash. echo 50;exitè un modo abbastanza semplice per terminare il programma bash. Be 'quasi.

Il problema più grande qui è che bash, durante l'esecuzione exit, continuerà ad analizzare fino alla fine della riga corrente (anche se non esegue il codice in questione), quindi dobbiamo assicurarci che non ci siano errori di sintassi sul resto di la linea. Abbiamo 'subito dopo exit;che non è (e non può essere) immediatamente abbinato. Più tardi sulla linea, '…'viene usato per nascondere un po 'di codice Brain-Flak dai linguaggi di scripting, ma ciò lo svelerebbe da bash. Di conseguenza, dobbiamo cambiare il tipo di stringa letterale che stiamo usando per nascondere il codice, passando da stringhe a virgoletta singola a stringhe tra virgolette doppie. or"'"fa il trucco senza disturbare Perl, Python o Ruby (poiché l'argomentazione della mano sinistra è veritiera in ogni caso).

Ora abbiamo una doppia citazione senza eguali che si estende su una linea futura. Era abbastanza difficile chiuderlo senza disturbare almeno un'altra lingua; ciò che effettivamente facciamo è cambiare il modo in cui nascondiamo il codice da bash da virgolette doppie a virgolette singole senza pari in un commento Python / Ruby sulla riga successiva, e infine chiudere la virgoletta singola alla fine della riga successiva.

Pyth e 05AB1E

Fare casino con le virgolette doppie disturba anche le lingue che stavano usando stringhe tra virgolette doppie per nascondere codice, Pyth e 05AB1E. Il trucco principale che usiamo qui è quello di garantire che ogni doppia citazione che aggiungiamo abbia un'altra doppia citazione subito dopo al fine di esporre il minor codice possibile. (Questo spiega la doppia citazione aggiuntiva sulla __DATA__riga, che non è necessaria per bash.) Pyth usa \come carattere di escape; il risultato principale di questo è che ha limitato l'ambito che avevo per fare confusione con le stringhe nei linguaggi di scripting, costringendomi a usare il metodo piuttosto contorto sopra (poiché non potevo facilmente usare la differenza di \comportamento tra bash e tutto altro). In 05AB1E,' agisce come caratteri di escape all'esternostringhe, e farla fuggire dal comando "non lo farebbe. Quindi ho finito per aver bisogno di inserire un carattere di imbottitura inutile (in difetto al mio solito x; rende le cose più facili da leggere!) All'interno dei "'"costrutti che vengono utilizzati per cambiare tra gli stili di quotazione bash.

Preludio

Di gran lunga il linguaggio più difficile da risolvere qui. Il problema è che la linea di scripting, con tutte le sue parentesi, è stata spostata lateralmente, e quindi il flusso di controllo Prelude (che tiene molto al modo in cui le parentesi sono allineate verticalmente) è stato completamente distrutto. Ho dovuto quindi provare a ricostruire qualcosa che funzioni.

Peggio ancora, l'attuale prima riga (che non volevo davvero riscrivere) pone un limite al punto in cui possono apparire le parentesi. Inizia con una cifra diversa da zero (due di loro, in effetti!), E presto è seguito da una parentesi iniziale. Questo è un ciclo in Prelude e i cicli all'inizio del flusso di controllo in Prelude causano una serie di problemi diversi (principalmente perché causano l'esecuzione di più codice anziché di meno). Come tale, avevo un disperato bisogno di aprire un ciclo di iterazione 0 su un'altra riga per saltare quel codice. La mainlinea per il programma C è molto adatta, ma dobbiamo stare molto attenti a dove si trova la staffa di chiusura corrispondente; troppo a destra e la parentesi senza pari sul#R+la riga causerà problemi, troppo a sinistra e non commenterà abbastanza codice. (Tieni presente che una parentesi aperta su una riga può corrispondere a una parentesi chiusa o su una riga diversa.)

Una volta fatto, abbiamo abbastanza spazio per attaccare una parentesi aperta sulla linea dell'Incidente, e finalmente abbiamo superato in sicurezza i primi caratteri del programma. Tuttavia, la differenza nei posizionamenti tra parentesi finisce per significare che parte del codice Incidente / Vortice viene effettivamente eseguito in Preludio, corrompendo lo stack. Invece di cercare di impedirlo, ho spostato alcuni degli zero di Whirl più a destra, consentendo loro di darci di nuovo un programma Prelude funzionante.

Un altro piccolo cambiamento è stato sulla prima riga del programma; la parentesi finale della linea era in una posizione che era molto difficile da evitare. Ho aggiunto un extra csubito dopo il codice Pyth per spostarlo a destra. (Molte lingue analizzano quel punto del programma, quindi ci sono voluti una quantità sorprendente di tentativi ed errori per trovare un carattere di riempimento che non avrebbe rotto almeno una lingua!)

Incidente

Preludio è stato abbastanza difficile da solo, ma far lavorare Preludio e Incidente allo stesso tempo è stato da incubo. Preludio ha posto molti vincoli al codice che mi ha impedito di muovere liberamente le cose, e quindi ha reso più difficile la costruzione di gettoni accidentali nel golf. Ad esempio, Prelude ha bisogno solo di uno 0spostato a destra, ma ciò ha provocato il 00fallimento di un token, interrompendo alcuni dei token desiderati come parte del programma Incidente (perché se due token si sovrappongono, vengono entrambi rifiutati e l' 00era sovrapposizione di un token che volevamo in aggiunta alla sovrapposizione stessa). Ho dovuto spostare entrambi fuori per fare una quarta copia e impedire che venisse addirittura considerato un token.

Più sottili sono i token ;'e ␠␠(cioè due caratteri spaziali). Il problema è che entrambi appaiono prima di quello kGche viene utilizzato per saltare all'inizio del programma e quindi interromperanno il flusso di controllo dell'Incidente (oltre a interrompere il punto centrale del programma).

Rimuovere una copia di ␠␠suddividendola non sembra fattibile. Rimuoverlo attraverso la sovrapposizione potrebbe essere possibile ( ␠=è una potenziale sovrapposizione promettente), ma è quasi certamente meno prolisso aggiungere solo una quarta copia, che è quello che ho fatto qui.

Nel frattempo, possiamo usare un trucco diverso per ;'. Rompere non è qualcosa che volevo provare, dato che è usato in situazioni abbastanza sensibili alla spaziatura. Tuttavia, non è così vicino all'inizio del programma (nonostante appaia sulla prima riga), quindi è plausibile che potremmo saltarci sopra (facendo sì che non influenzi il flusso di controllo) piuttosto che averne bisogno che non esista. Ho cercato un gettone adatto da usare per il salto che non rovinerebbe nessuna delle altre lingue. /vappare un po 'prima sulla prima riga e non rompe nulla, quindi è quello che ho usato.

50 lingue in 1 Kib di codice

@MistahFiggins ha sottolineato che il mio invio a 1025 byte sarebbe molto più ordinato se fosse 1024 byte (soprattutto perché la cinquantesimo lingua è una pietra miliare a sé stante). Ciò ha richiesto la ricerca di un byte di risparmio da qualche parte. In questo caso, ho salvato tre byte in Deadfish ~, a scapito di due byte extra utilizzati per allineare correttamente i token Incidente, portando così esattamente il programma a 1024 byte.

In precedenza, la formula utilizzata dal codice Deadfish ~ era (2² + 2) ² + 10 × 1 + 2 = 48. La nuova formula è (3²-2) ²-1, producendo anche 48. Sorprendentemente, non è quello molto più breve da scrivere in Deadfish ~, nonostante sia notevolmente più semplice.

Questo ci dà anche un punteggio VIP di .008192. Questo non è solo un nuovo record, è anche un numero ben arrotondato a sé stante (il che è, ovviamente, una conseguenza della presenza di numeri arrotondati come input per la formula).

37. C ++ (gcc), 776 byte

#  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

␉è una scheda letterale, ␛un carattere letterale ESC; Stack Exchange altererebbe il programma altrimenti. Ti consiglio di copiare il programma dalla casella "input" del link TIO qui sotto, se vuoi lavorare su di esso.

Provali online!

Corri giù

Questo programma stampa 37 in C ++, 36 in Labyrinth, 35 in INTERCAL, 34 in Rail, 33 in Incident, 32 in Whirl, 31 in Modular SNUSP, 30 in Whitespace, 29 in Trigger, 28 in Brain-Flak, 27 in Perl 6 , 26 in 05AB1E, 25 in Pip, 24 in Thutu, 23 in Esagonia, 22 in Sottocarico, 21 in Nim, 20 in Preludio, 19 in Reng, 18 in Cardinale,17 a Julia, 16 a Pyth, 15 a Haystack, 14 a Turtlèd, 13 a Ruby, 12 a Fission, 11 a Befunge-98, 10 a Befunge-93, 9 a Perl 5, 8 a Retina, 7 a Japt, 6 in SMBF, 5 in Python 2, 4 in> <>, 3 in Minkolang, 2 in V / Vim e 1 in Python 3.

Verifica

La maggior parte delle lingue sono testate dal driver di test mostrato sopra. Puoi testare Reng qui e SNUSP modulare qui ; producono rispettivamente 19 e 31, come richiesto.

Ho aggiunto un altro formato all'output del driver di test che sfugge alle virgolette doppie e alle sostituzioni del feed di linea. Questo è così posso alimentare la spezzata singolo programma ac (gcc) ho avvolto intorno alla funzione creato da @feersum qui . Spero che altri possano usarlo così com'è.

Ecco il programma token Incidente . Idealmente, vorrei eliminare i token poiché sono un po 'difficili da leggere, indicare il token "centrale" e includerlo nel driver di test. Ma non so davvero come fare altro se non far sì che vari programmi stampino numeri interi sequenziali, quindi questo è quanto ho ottenuto.

Ho tentato di risolvere gli ovvi problemi di incidente, come i token dopo l'inizio e la fine dei token di salto e tutto ciò che sembrava estraneo, ma non ho bilanciato i token da mettere 0oal centro. Non sono sicuro di quale sia esattamente la logica per determinare il centro. Spero che @ ais523 ti aiuti. Questa stringa vicino alla fine 7LEintndus({})!<>+sarebbe tutto un token se non fosse per questa quarta inclusione nel codice. Tutti questi possono essere rimossi (e sostituiti con un .allineamento per Esagonia) al fine di regolare il token centrale.

Aggiornerò e riaccendiamo questo post il giorno o due successivi per esaminare il codice (supponendo che l'Incidente possa essere verificato / corretto senza andare oltre il conteggio dei byte). Ma adesso è super tardi, e per lo più volevo farlo uscire prima che dovessi risolvere un altro problema simile a Labyrinth. : P

Spiegazione

Come funziona il codice C ++.

Penso che molte persone abbiano abbastanza familiarità con il C ++, quindi non entrerò in troppi dettagli. I commenti di blocco si presentano sotto forma di /* comment */. I commenti di riga si presentano sotto forma di //comment. Il codice effettivo utilizzato da C ++ per produrre la risposta è int main() {std::cout<<37;}. E la libreria utilizzata per interfacciarsi con STDOUT è referenziata da questa affermazione #include<iostream>.

/ * Commenti Abuso * /

Per me, la storia del C ++ risale alla mia risposta Brain-Flak.

Dopo aver finalmente trovato il n. 28, ho iniziato a studiare alcuni altri poliglotti pubblicati in PPCG e tutto ciò che lo studio mi ha portato a poche risposte facili (la maggior parte di questi sono ancora disponibili per essere trovati se qualcun altro è così propenso). Ma soprattutto, sono giunto a una conclusione sui poliglotti in generale: i poliglotti di grandi dimensioni tendono a rientrare in una di due grandi categorie: #abuso di /*commenti o abuso di commenti.

Questo non è un fatto o una limitazione in ogni caso, ma di una struttura mentale personale che ha guidato le mie successive risposte.

Da qui ho pensato che se questo fosse diventato il poliglotta più grande del mondo, che presumo sia attualmente, sarebbe meglio se potesse sfruttare l'abuso di commenti da entrambe le famiglie di commenti. Così ho deciso di trovare un modo per incorporare un /*linguaggio di commento e spinto verso la famiglia C a causa principalmente di una familiarità personale.

Test iniziale C ++

Il mio processo iniziale di pensiero per questo era usare C # principalmente a causa della mia familiarità e il primo ostacolo per C # era portare il poliglotta in uno stato in cui poteva accettare una linea che non era iniziata #senza essere altrimenti trattato come codice dai linguaggi di scripting . La risposta Rail, insieme a diverse risposte inflating a byte che portano ad esso, ha risolto questo pezzo.

Successivamente è arrivato il problema di come avviare il primo /*blocco di commenti. Sapevo che la linea avrebbe dovuto iniziare la linea con un #per rimanere invisibile a Perl, Ruby e Python, ma qualunque cosa venisse prima /*sarebbe stata letta da C #. All'inizio ho provato un #regiontag C # , ma si è rivelato troppo increspato per i linguaggi 2D. Inserisci C ++.

Il C ++ ha diverse direttive per il preprocessore che iniziano tutte #, che offrono molte opzioni per i linguaggi 2D da attraversare. Ma si è scoperto che tutti erano incompatibili con almeno una lingua e, essendo in uno spazio di codice esposto in C ++, avevo soluzioni alternative limitate. Per frustrazione e disperazione, mi sono imbattuto nel fatto che il C ++ avrebbe semplicemente accettato un singolo #prima del blocco dei commenti. Va bene, qualunque cosa sia fattibile. Quindi sono andato avanti con la presunzione che #/*potrebbe funzionare come i primi tre personaggi del poliglotta.

Il secondo pezzo di verifica di base era garantire che l'effettiva dichiarazione di stampa potesse vivere felicemente con gli altri codici. Sapevo dalla risposta di Brain-Flak che a Japt non piacevano i non scappati {e che era necessario per dire int main() {std::cout<<37;}C ++ e C ++ non avrebbe permesso al personaggio di fuga di Japt nel mezzo del suo codice. Questa volta ho avuto la fortuna di scoprire che se avessi abbandonato la stringa letterale di Japt solo per questa affermazione, Japt avrebbe comunque felicemente prodotto lo stesso risultato.

Nel frattempo, a Brain-Flak non piaceva {}neanche l' uno, ma sono stato di nuovo fortunato a scoprire che C ++ andava bene con una #tra le sue int main()e le {std::cout<<37;}dichiarazioni, permettendo alle parentesi graffe di essere commentate dalla prospettiva di Brain-Flak.

Quindi, con i principali problemi del C ++ dimostrati teoricamente risolvibili, ho iniziato l'arduo processo di risoluzione di tutti gli errori che avevo introdotto.

Paesaggio 2D

La parte più difficile di questa risposta è stata di gran lunga la riconfigurazione delle prime due linee del poliglotta. E il problema più significativo è stato il *. Sottocarico non consentirà un *precedente a (. Lo considera un'operazione matematica su uno stack vuoto, che ritiene essere un errore. Quindi il poliglotta richiedeva un (precedente al /*ma C ++ non poteva permetterlo. Quindi la soluzione è stata per noi un commento di riga C ++ //sulla prima riga per nascondere a (e quindi iniziare la seconda riga con a #/*.

Successivamente, a Befunge non piaceva davvero l'idea di un /senza che qualcosa fosse diviso, ma dopo aver studiato la risposta Begunge esistente 16/"<"6/b.q@mi sono imbattuto nell'idea di un numero e una stringa si è fracassata prima del //. Ha funzionato e non ho idea del perché C ++ sia d'accordo, ma accetta # 1"16" 2come dichiarazione di apertura. Non lo metterò in discussione, ma so che gli spazi sono necessari perché funzioni.

Linea Uno

Japt si è rivelato piuttosto sensibile allo spazio e non voleva davvero entrare nella sua stringa basata sul backtick nella riga superiore, quindi esso e il backtick di Pip sono stati spostati sulla seconda riga, costringendo molta ginnastica linguistica sulla riga 1.

• Pip non gradiva la maggior parte della linea 1, quindi un secondo spazio è stato posizionato dopo il primo #per indicare un commento.
• Il (sottocarico doveva essere evaso da Japt con un precedente \.
• #è un terminatore di salto in Turtlèd quindi era necessario, ma Pyth lo considera un ciclo di terminazione dell'errore, quindi Pyth aveva bisogno di una divisione per null / dopo il#
• Non sono più sicuro di cosa @stia facendo la prima riga, ma Pyth e Japt sembrano apprezzare la sua presenza meglio di così, sebbene @non sia un personaggio significativo secondo la documentazione di Pyth.
• E sembra che il primo ;possa essere rimosso a questo punto senza conseguenze, quindi non sono sicuro di cosa si risolvesse più lì, anche se sospetto che fosse legato a Pyth. Ma sembra che le soluzioni future possano salvare un byte omettendo quello.
• <> <e Turtlèd funzionano entrambi sostanzialmente come prima con <> <riflettendo sul primo #e spostandosi alla fine della prima riga. E Turtlèd salta #come ho già detto e termina con la "14"corda che stampa.

Routing 2D

Con la risoluzione di questi problemi, la fase successiva era il routing dei linguaggi 2D. In precedenza l'iniziale vera stato ignorato dai Befunges a causa del precedente #, ma ha mandato giù Haystack e Minkolang. Ora, lo spazio iniziale tenta di inviare Minkolang lungo la terza dimensione, a cui la sua documentazione si riferisce come dimensione temporale.

A parte la terza dimensione di Minolang: per me è una specie di termine improprio chiamarla dimensione del tempo, mi sembra davvero più spaziale che temporale. Non l'ho capito fino a quando non ho trovato questo link che illustra il concetto e sembra più simile ai livelli multipli di una scacchiera 3D. La mia convinzione è che in questo modo funzionano in genere i linguaggi 3D. Ma poiché questo era un nuovo concetto per me, ho pensato di buttare queste informazioni per gli altri.

Così strati multipli di Minkolang sono delimitate da linee che terminano in $$$cui ho buttato sulla fine del codice della guida qui: #-3o4o#$$$. Ora, Minkolang colpisce lo spazio e cade alla prima >in <>3N.<> ␉//e procede a destra in uscita 3. #>non potevano essere ammesse alla partenza di questa linea, perché avrebbe tentato di interrompere un blocco di commento Perl6, quindi <viene usato al posto di #equilibrare per SMBF e cervello -Flak. Tuttavia, questa è una procedura di scambio di stack Brain-Flak, quindi una seconda serie di <>viene utilizzata dopo la fine di Minkolang per tornare alla risposta corretta di Brain-Flak.

Allo stesso modo Labrynth si scontra contro lo spazio, ma fa sì che Labrynth si sposti verso il basso nella colonna 1. Poi gira verso il basso la linea 2 dove scende verso i 3colpi di un altro muro, facendolo girare di nuovo a sud e colpendo un ;che fa scattare il 3 . Quindi il programma continua a destra dove 36 vengono memorizzati e stampati, prima di trovare finalmente @un'uscita. Questo percorso è più lungo di quanto deve essere, ma ho scoperto che Prelude avrebbe emesso un nul byte prima che fosse normale 20 se !fosse più a sinistra di quanto non sia ora, indipendentemente dalla linea che appare. Quindi l'ho reso più corretto, perché avevo lo spazio per farlo.

Successivamente, il percorso di Haystack è stato modificato perché /ora precede la vlinea 1 e riflette il suo percorso verso l'alto come Reng. Fortunatamente, Reng convive piuttosto pacificamente. L'unico problema era che l'ago di Haystack |era un riflettore in Reng, quindi un Reng usa un Befunge come un salto ( #) sopra l'ago per concludere correttamente Reng.

I Befung continuano lungo la linea 1 fino a quando non vvengono indirizzati verso il basso e poi a destra sulla seconda riga per concludere con lo stesso codice usato in precedenza. La mia sensazione è che questo pezzo possa essere appiattito un po 'ora che un minor numero di lingue sta tentando di attraversare in modo significativo il codice, ma non ho bisogno di altri muri per sbattere la testa, quindi l'ho lasciato così com'è.

Infine, il punto di partenza del cardinale è %che non aveva particolari necessità di essere confuso nelle prime due linee già dense. Quindi l'ho spostato sulla stringa di Python. Anche i suoi percorsi di codice multipli sono ora delimitati da x's, che termina lo spostamento del suo puntatore.

Linea 2 e 3

L'unico cambiamento significativo qui è che tutti sono :stati sballottati per una ragione o per l'altra. Forse i (bisogni di Prelude o forse erano semplici problemi di conteggio dei byte - probabilmente entrambi. L'altra cosa è che il codice di salto del trigger è stato spostato indietro e rinominato come auaaZ. Ho avuto spazio da riempire per incontrare il percorso del codice di Befunge e questo mi è sembrato il migliore. Inoltre, <questo articolo serve a bilanciare quanto segue SMBF >. Finalmente, i soli ”vicino alla fine della seconda riga devono mantenere la stringa di 05AB1E. Inoltre, yysulla riga 3 sono presenti solo caratteri di riempimento per Labyrinth.

The Big String Esolangs

Con le prime due righe risolte, era tempo di iniziare a scavare negli esolang a analisi più completa, e Pip si è rivelato avere un problema. Se ricordi che abbiamo affrontato le parentesi graffe {std::cout<<37;}uscendo dalla stringa Japt per consentire a Japt di trattarlo come codice. Bene, Pip sta usando la stessa sintassi della stringa e questa riga non è piaciuta come codice e Pip ha opzioni di dichiarazione delle stringhe molto simili a quelle di Japt. Entrambi usano un singolo 'per dichiarare una stringa di un carattere, entrambi usano la stessa dichiarazione di escape \ed entrambi accetteranno "come identificatori di stringa. Quindi era difficile far credere a Pip che si trattasse di una stringa senza che Japt credesse allo stesso modo.

Si è scoperto che Japt aveva una differenza sfruttabile: #prende il valore ascii del personaggio successivo. Quindi, #"`terminerà la stringa Japt / pip, quindi dirà a Japt di prendere il valore asci ", mentre dice a Pip di iniziare una nuova stringa. La "probabilmente avrebbe potuto essere un backtick invece, e probabilmente sarebbe stato meglio, ma la mia linea di pensiero è stato quello di utilizzare un diverso identificatore di stringa al suo interno come un altro punto di manipolazione delle stringhe. Quindi, ecco un altro posto in cui è possibile salvare alcuni byte lungo la strada.

Successivamente, ho dovuto iniziare la stringa Japt dopo le parentesi graffe, consentendo a Pip di rimanere in una stringa. Ho fatto questo con '"`una sola citazione, una doppia citazione e un backtick. Per Japt il 'non è in una stringa ed è quindi un indicatore per prendere il carattere successivo come una singola stringa di caratteri. Pip vede 'come parte della stringa e termina la sua stringa con ". E infine, `indica sia a Pip che a Japt che sta iniziando un'altra stringa che continua attraverso il poliglotta fino all'ultima riga in cui entrambe le lingue si completano felicemente.

Ora, sia Japt che Pip hanno lavorato a questo punto, ma 05AB1E non è riuscito a causa dell'uso di "alcuni errori che hanno indotto l'esposizione del codice. Fortunatamente questo è stato abbastanza facile da risolvere mettendo un altro insieme "intorno all'intera cosa, lasciando il set di manipolazioni delle stringhe come "`#"\\'*/{std::cout<<37;}/*'"`".

Infine, con la linea ora simile a questa, con int main() #/*"`#"\'*/{std::cout<<37;}/*'"`"cui Underload ha avuto un problema. Quelli consecutivi *sono stati un altro errore di sintassi, quindi ho lanciato a ()nel mezzo *per placarlo.

I fragili esolang

Il grande ostacolo ora era White Space. Non entrerò in un sacco di dettagli qui perché la maggior parte della soluzione di Whitespace è integrata nelle spiegazioni già fornite e ho appena esaminato i casi in cui lo spazio bianco ha costretto alcune decisioni. Ti sto guardando Labyrinth. Il grande cambiamento, tuttavia, è che il codice effettivo per l'output della risposta di Whitespace è sulla riga 2-4 anziché 1-3. Ciò è in gran parte dovuto all'esposizione al codice di Japt nella riga 1.

Thutu originariamente avuto problemi con quella che era stata questa linea: int main() #/*()"`#"\'*/{std::cout<<37;}/*'"`". Quindi, ho inserito un feed di riga poco prima del primo #per nascondere tutti i problemi dietro un indicatore di commento e poi ho spammato un sacco di /altri post che sono stati esposti al codice.

A questo punto ho allineato Hexagony e ho trovato un nuovo problema. Il codice, proprio all'inizio, che ha iniziato la vita come # 1"16" 1fatto l' +in /+23!@più chiaro lo stack. Quindi, ho appena rimosso l'IS e l'ho +trovato ora con l'output 123. Questo è stato abbastanza facile da risolvere modificando la mossa di apertura in # 1"16" 2e giocando a golf il pezzo Hexagony /3!@.

Whirl ha apportato alcune modifiche, ma si è trattato principalmente di assicurarsi che il numero giusto di 1 iniziali apparisse prima della linea Whirl-Incident. L'incidente, tuttavia, aveva un token particolarmente difficile. Ho avuto esattamente 3 copie di /*e */.

Inizialmente volevo solo buttare *//*qualsiasi vecchio posto nel codice per creare una quarta copia di ciascuno, ma Underload ha visto consecutivi* , il che era assolutamente impossibile. Alla fine ho gettato un /alla fine di questa linea int main() /*per farla finire /*/, pensando che avrei fatto sovrapporre i token, ma sono riuscito a creare solo 4 copie di uno dei due token. Giusto giusto. Funziona così. Vabbè, lancerò un simile /in finale */per fare un quarto lì. Dopo questo, ho sostituito un gruppo di no-op esagonali con una quarta copia di diversi token incidenti in questa stringa nell'ultima riga 7LEintndus({})!<>+.

Conclusione

Ok, questo è tutto il dettaglio che ho per questo enorme refattore. Prometto di non avere così tanto di cui scrivere la prossima volta. In realtà non ho idea se C ++ sia una scelta buona o cattiva per questo poliglotta, ma il mio senso apre alcune opzioni. Spero che questo porti a cose buone.

Buona codifica.

3. Minkolang v0.15 (26 byte)

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

Questo programma stampa 1 in Python 3, 2 in Vim e 3 in Minkolang v0.15

Spero di non sbagliare introducendo una lingua 2d

Provalo online!

Spiegazione

#                     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 ignora in qualche modo Minkolang, quindi va bene

E non c'è stato davvero alcun problema con Python poiché ignora i commenti #

Il prossimo...

Per la lingua successiva, suggerisco qualcosa come> <> poiché #agisce come un riflettore (in modo che la direzione cambierà a sinistra e si avvolgerà completamente a destra) in modo da poter aggiungere codice che può essere ignorato da altre lingue

5. Python 2 (35 byte)

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

Questo programma stampa 1 in Python 3, 2 in Vim, 3 in Minkolang v0.15, 4 in> <> e 5 in Python 2.

Provalo Beta online!

In Python 2, 1/2 è 0, che è un valore falso, che fa stampare Python 5. In Python 3, 1/2 è 0,5, che è un valore sincero, che fa stampare Python 1.

4.> <> (29 byte)

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

Questo programma stampa 1 in Python 3, 2 in Vim, 3 in Minkolang v0.15 e 4 in> <>

Provalo online!

Codice eseguito

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

Ancora un altro linguaggio 2D.

Non ha alcun effetto su Minkolang in quanto aggiunge personaggi dopo che la direzione cambia, viene ignorato da Vim per qualche motivo. #è un commento in Python, quindi non cambiare neanche loro.

28. Brain-Flak , 280 byte

#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

␛ rappresenta un carattere ESC letterale, come al solito.

Questo programma stampa 28 in Brain-Flak , 27 in Perl 6 , 26 in 05AB1E , 25 in Pip , 24 in Thutu , 23 in Hexagony , 22 in Underload , 21 in Nim , 20 in Prelude , 19 in Reng (testato qui ), 18 nel Cardinale , 17 in Julia , 16 in Pyth , 15 in Haystack , 14 in Turtlèd , 13in Ruby , 12 in Fissione , 11 in Befunge-98 , 10 in Befunge-93 , 9 in Perl 5 , 8 in Retina , 7 in Japt , 6 in SMBF , 5 in Python 2 , 4 in> <> , 3 in Minkolang , 2 in Vim / V , 1 in Python 3

Prima di tutto, voglio dire che privilegio è poter contribuire a questa sfida. Ho sentito parlare del code golf solo poche settimane fa e da allora mi sono appassionato moltissimo. La prima cosa che ho fatto quando ho trovato questa sfida era provare a eseguire il codice come in varie lingue solo per vedere se potevo trovare qualcosa su cui lavorare. Questo era quando eravamo al numero 6. Onestamente ho pensato che questa sfida fosse impossibile, ma eccoci qui (# 28 Wow!). Quello che ho scoperto in quel momento è che Brain-Flak ha prodotto il valore 2. Quindi ho deciso di impararlo.

Brain-Flak si è rivelato abbastanza grande per questo tipo di sfida perché è abbastanza facile da imparare e ignora praticamente tutti i personaggi tranne (){}[]<>. #capita anche di commentare qualcosa dopo di esso sulla stessa linea, quindi l'unica parte dell'ultima presentazione che è stata mai presa in considerazione per Brain-Flak era print((eval("1\x2f2")and 9 or 13)-(0and 4)^1<<65>>62)che poi si è abbinata ((())()<<>>). Quindi, il piano è diventato l'aggiunta di parentesi superflue a quello che sono arrivato a pensare come il codice Python.

Ho modificato i bit di Python per analizzare in Brain-Flak a ((() () ())()()<<()>>)cui equivalgono a 2 stack il primo essendo 5 e il secondo essendo 3. Dopo di che sto quadrando il 5 con({({})({}[()])}{}) e aggiungendo il risultato a 3 con ({}{}). Questa quadratura e aggiunta avviene in una stringa dal punto di vista di Python. Non posso pretendere di comprendere il ragionamento di Python qui, ma sono abbastanza sicuro che questa stringa non venga altrimenti valutata da altre lingue in modo significativo, con solo un paio di eccezioni.

Japt, a quanto pare, interpreta le parentesi graffe all'interno di una stringa come contenenti codice, ma queste erano abbastanza facili da scappare \prima di ogni{ in questa stringa. Ma questo ha gonfiato il conteggio dei byte. Così è la vita.

Il preludio è stato abbastanza indulgente con tutte le mie parentesi. Un precedente commento indicava che Preludio si sarebbe adattato a Pparentheses allineati verticalmente e mi è capitato di crearne solo uno. Dolce! L' (nella riga superiore allineati con l'e (9nella grande linea. Quindi ho dovuto aggiungere uno spazio aggiuntivo prima della prima (riga. La mia ipotesi qui è che il doppio spazio fosse un indicatore di commento per qualcosa, quindi l'aggiunta di uno spazio aggiuntivo sembrava banale e ha funzionato. Dovrei sottolineare che invece ho provato ad aggiungere spazi aggiuntivi (9), ma Cardinal non ha collaborato.

05AB1E non mi è piaciuto il mio primo tentativo di incapsulare la stringa Python tra virgolette doppie, ma tutti sembravano graditi usare virgolette singole. Non è un grosso problema lì.

L'esagonia era l'unica lingua rimasta a questo punto, ed ero ovviamente molto oltre la soglia esadecimale successiva, quindi era tempo di sporcarsi. Il /^23!@è il codice Hexagony e io sono super eccitato a questo proposito, perché penso che farò future aggiunte molto più facile. Questo piccolo pezzo può sostanzialmente essere spostato in qualsiasi punto della stringa di pitone senza sballare alcun codice. Questa è la stringa completa, quindi siamo tutti sulla stessa pagina '(\{(\{})(\{}\/^23!@[()])}\{})(\{}\{})'. Il /qui imposta il percorso di Hexagony da SE -> NW a W-> E su questa stringa, che abbiamo un sacco di margine di manovra. (Il precedente \è scappare/per thutu BTW). La mia idea qui è se si apportano modifiche, le probabilità sono che finirai per attraversare questa stringa ad un certo punto e puoi far scorrere il pezzo Hexagony all'interno della stringa per catturare il percorso del codice e inviarlo alla conclusione corretta. Fai solo attenzione a non fra Japt \e il {. In caso di problemi, la invece di . Inoltre, potresti notare che la mia soluzione ha rimosso il file@a destra della stringa è appena lasciato da un'altra soluzione Hexagony e può essere rimosso senza conseguenze per le altre lingue. E ovviamente se ti capita di imbatterti nel percorso del codice di Hexagony andando nella direzione opposta, puoi ovviamente usare il codice per mantenere le cose sotto il limite di byte. Qualcuno ha menzionato qui che questo era per l'allineamento di Hexagony e non ne avevo più bisogno.@!32^\/^23!@===2

Finalmente, ecco un piccolo pezzo di codice che ho trovato durante l'esplorazione di codegolf che converte una riga di testo in un esagono leggibile da Hexagony in modo da poter eseguire il debug. Sono sicuro che molte persone lo sanno, ma non l'avevo visto pubblicato qui, quindi potrebbe aiutare anche qualcun altro. Un avvertimento equo, devi modificare l'input per rimuovere i backtick e i ritorni a capo, nonché scambiare la fuga letterale con qualcosa che occupa una normale quantità di spazio per ottenere il codice per allineare le cose in un grazioso esagono.

PS Mentre stavo scrivendo questo, mi sono reso conto di avere un errore. Avevo creduto di cancellare il bordo della memoria di Hexagony per con il ^, ma apparentemente posso sostituirlo con una no-op a nessuna conseguenza. Questo ^dovrebbe probabilmente essere un +se provi a manipolare questa sezione. Apparentemente stavo passando un +precedente, ma i futuri poliglotti potrebbero non essere così fortunati.

In bocca al lupo!

38. C, 804 byte

#  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

␉è una scheda letterale, ␛un carattere letterale ESC; Stack Exchange altererebbe il programma altrimenti. Ti consiglio di copiare il programma dalla casella "input" del link TIO qui sotto, se vuoi lavorare su di esso.

Provali online!

Corri giù

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

Verifica

La maggior parte delle lingue sono testate dal driver di test mostrato sopra. Puoi testare Reng qui e SNUSP modulare qui ; producono rispettivamente 19 e 31, come richiesto.

Ecco la mia versione leggermente modificata del tokeniser Incidente , progettata per essere un po 'meno giocata a golf ma un po' più utile.

Spiegazione

Ho sempre amato fare piccoli poliglotti, ma mai uno così grande; Ho pensato che probabilmente avrei dovuto provarlo!

Dopo la meravigliosa risposta C ++ di @ Chance, C sembrava la scelta logica successiva, e dato (rispetto ad alcune risposte precedenti) la relativa facilità di aggiunta, ho deciso di provarci quando ne ho avuto la possibilità!

Ho usato un trucco molto noto per dire la differenza tra C e C ++; la dimensione di una costante di carattere è 1 byte in C ++ ma la dimensione di un int (garantito di almeno 16 bit) in C. Questo codice dovrebbe essere molto portatile (tranne forse per i sistemi che usano byte con abbastanza bit per adattarsi a un int) a meno che Ho fatto uno stupido errore.

In primo luogo ho provato a fare una printfcosa con tutto in linea, ma le parentesi multiple sembravano causare problemi a Japt, quindi ho semplificato la linea, il che sembrava risolverlo.

Successivamente, al cardinale non è piaciuto, ho indovinato a causa della %stampa, quindi ho dovuto risolverlo passando a manipolare le stringhe.

Il mio tentativo successivo, tentando di assegnare una stringa e poi cambiare il secondo byte in base al comportamento C, è finito troppo a lungo e avrebbe spinto Hexagony nella dimensione successiva; Volevo evitare di rifarlo mantenendolo all'interno dei personaggi extra con cui dovevo giocare! Avevo bisogno di ogni byte che potevo ottenere per questo, quindi ho implementato le modifiche di risparmio di byte suggerite da @Chance.

Quindi ho scartato un po 'quel codice C e ne ho trovato puts(sizeof'c'-1?"38":"37");quasi funzionante, tranne per il fatto che Underload era segfault, presumibilmente a causa della complessa espressione tra parentesi.

Anche dopo aver rimosso il extra >>che era necessario per abbinare <<in Perl6, non sono riuscito a ottenere un modo abbastanza conciso di dividere la parte più complessa di esso in un incarico di array di caratteri. Così ho finito con l'usare invece il preprocessore.

Dopo molte prove ed errori ho trovato una soluzione che a Retina sembrava piacere. Il preludio che mi stava causando problemi avanti e indietro, finì per risolversi prima che mi girassi per vedere perché si stava rompendo (immagino che le parentesi o l' !avevo nel ternario in una fase, guardando risposte precedenti).

Nel frattempo stavo riparando lo spazio bianco per ottenere qualcosa che gli spazi bianchi avrebbero voluto; Ho scoperto che è piuttosto facile. In particolare, è tab space space spacestata una combinazione molto utile (l'istruzione per aggiungere i primi due elementi in pila), poiché significava che potevo aggiungere spazi bianchi a linee senza altri spazi bianchi senza che tutto fosse fuori sincrono (indovino la sua posizione nella programma significa che in realtà non viene mai eseguito, quindi non sono preoccupato per i underflow dello stack qui).

Ora ho testato Incidente e funziona! Mille grazie a @Chance e @LliwTelracs, che ho appena realizzato NON è un nome gallese, per avermi aiutato ad afferrarlo. Vedi questa evidenziazione della sintassi . Ho rimosso il ;token che era visualizzato prima del #yytoken. L'ho fatto semplicemente aggiungendo un extra ;dopo la getsdichiarazione (il mio precedente tentativo riguardava la sostituzione s(che ora appare molto più nel programma C rispetto al precedente) nella stringa "detokenising" con un ;, ma alla fine ero in realtà un personaggio abbreviato per Hexagony (grazie a @Chance), quindi dopo i tentativi di aggiungere un personaggio in più a quest'ultima riga fallito, l'ho appena cambiato e ho aggiunto il punto e virgola altrove).

Ho anche modificato un po 'lo spazio bianco per cambiare alcuni altri token per fare un tentativo di centratura, per ricollegare to Line Linefeed (spostando la linguetta alla fine della #includelinea verso il centro, facendo così tre token), e per de-tokenizzare il token triplo spazio spostando uno spazio nella definelinea.

Alla fine, un giorno dopo l'invio iniziale, ho deciso di andare in fondo all'avvertimento del preprocessore spaventoso che la gcc ha prodotto (e che ha fatto fallire Clang). Ho determinato che il motivo per cui la prima riga ha funzionato è perché è l'output del preprocessore che fornisce informazioni di debug come nomi di file e numerazioni delle righe originali. A loro non piaceva il primo "2" sulla prima riga, perché ciò significava "tornare da un file incluso nel file specificato", e ovviamente questo è impossibile dato che non ci sono stati file inclusi. Dopo averlo modificato in un "1" (avvia intestazione normale), ho fatto soffocare un po 'di troppe lingue, l'ho cambiato in un "3" (avvia intestazione componente interno), che ha rotto solo Hexagony, poiché ora si basava sul 2. Quindi all'inizio del codice Hexagony ho aggiunto una parentesi aperta(per ridurre il 3 a 2, quindi una parentesi chiusa )dopo la fine ( @) del codice esagonico per soddisfare Retina, Prelude e Underload che tutti si aspettavano parentesi corrispondenti. Riprovare a test Reng e Modular SNUSP non ha prodotto problemi e i token Incidente hanno funzionato correttamente, quindi ora l'ho risolto! L'ho testato su una varietà di architetture esotiche e sembra funzionare. So che non è importante per un codice golf, e non mi dispiacerà se i futuri mittenti dovranno rompere questo per mantenere un numero di byte o altro (o se qualcuno ha già iniziato sulla base di questa soluzione e non vuole cambiare il loro troppo), ma c'è una buona ragione per cui l'ho fatto: il compilatore Objective-C di TIO supporta solo Clang, quindi sarà molto utile se qualcuno vuole aggiungerlo!

Ricorda che non ho mai usato la maggior parte di queste lingue, spero che il mio successo incoraggi più nuovi arrivati ​​a provarlo!

65. ALGOL 68 (Genio) , 1634 byte

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

Punteggio VIP ( stampante a numeri interi versatili ): .005949 (per migliorare, la voce successiva non deve superare i 1710 byte)

Provalo online!

Corri giù

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

Verifica

La maggior parte delle lingue può essere testata con il driver di test sopra, ma 6 lingue devono essere testate localmente.

• Reng può essere testato all'uscita 19 qui .

• Modulare SNUSP può essere testato per uscita 31 qui .

• L'incidente è stato verificato per testare 33 tramite il bilanciamento manuale dei token.

• Deadfish ~ può essere testato per produrre 48 localmente, usando questo interprete . Nota che Deadfish ~ prende il poliglotta da alimentare su stdin, ma stampa una serie di >>prompt sullo standard output, che non sono inevitabilmente conseguenza dell'esecuzione di qualsiasi programma Deadfish ~.

• Moorhens 2.0 può essere testato sull'uscita 60 usando questo interprete .

ALGOL 68

ALGOL è probabilmente il meno noto dei quattro linguaggi di programmazione di alto livello sin dai primi tempi della programmazione - le lingue rimanenti di questa nebulosa distinzione sono COBOL, FORTRAN e Lisp. All'epoca ALGOL era meglio conosciuto nei circoli accademici e matematici, ma oggi è meglio conosciuto per la sua enorme influenza sulle lingue moderne. In effetti, la maggior parte dei linguaggi pratici moderni può essere descritta come "simile all'Algol", non ultimo il C, che ovviamente ha il suo lignaggio di influenze e derivati.

Sono piuttosto entusiasta di includere ALGOL perché è un altro importante trampolino di lancio nella storia del computer che possiamo aggiungere a questo monumento che chiamiamo poliglotta. Sono cose fantastiche.

ALGOL68 è l'ultima delle tre principali specifiche ALGOL, le altre sono ALGOL60 e ALGOL58. È interessante notare che la specifica non ha una sintassi fissa, il che significa che i token sono definiti, ma non gli spelling. Ciò rende il linguaggio fortemente dipendente dall'interprete perché ogni interprete può usare un simbolo diverso per avviare un blocco di commenti, ad esempio. La specifica descrive l' ¢avvio di un blocco di commenti. Ma poiché ¢non è tra i codici ascii di base 127, comprensibilmente non vede molto uso come indicatore di commento tra gli interpreti disponibili. Ebbene si scopre che l'interprete Genie incantesimi ¢come #, che è tutto l'apertura abbiamo bisogno di ottenere il carattere passato 1 e fare un poliglotta.

Genie infatti ha tre opzioni di sintassi per i commenti, le altre due sono coe comment, entrambe specificate come scritte in grassetto. Sì, audace. Se usiamo il corsivo, questa è una variabile. Genie ha risolto il problema ancora una volta, scrivendo in grassetto in maiuscolo. E poiché COnon è nel poliglotta da nessuna parte, abbiamo un metodo semplice per nascondere il poliglotta dal parser. Se COper una lingua è necessaria la strada , possiamo passare alla COMMENTsintassi più dettagliata .

Non ci sono commenti in linea in ALGOL: sono tutti in stile blocco, il che significa che devono essere terminati. Dato lo stato iniziale del poliglotta, il nostro commento sul blocco ALGOL viene aperto immediatamente e termina vicino alla fine della linea 1 perché Turtlèd utilizza in modo simile #un token di salto. Per fortuna Turtlèd non ha problemi a camminare tra i caratteri Ce O, quindi nella riga 1 possiamo semplicemente inserire COimmediatamente dopo il secondo #per dare inizio ad un commento fat block per ALGOL68.

Da qui non ci resta che posizionarci COprint("65")da qualche parte. Ho scelto l'ultima riga perché ho preferito finire la riga con un'altra# commento e non volevo che il commento terminasse #all'inizio dell'ultima riga. Quindi seguiamo la nostra dichiarazione di stampa ALGOL con #se #come l'ultimo carattere nel poliglotta. L' sa #sè per alphuck per bilanciare il pin stampa.

Grazie a @ ais523 per aver aperto la fine del poliglotta con la risposta 59 e aver reso tutto ciò possibile.

SMBF

Abbiamo aggiunto un carattere diverso alla fine del poliglotta per terminare il commento finale di ALGOL e SMBF in precedenza stava leggendo l'ultimo carattere per la sua risposta. Per ovviare a questo, ho dovuto cambiare SMBF per leggere il penultimo carattere modificando questo codice alla riga 8 [.>-]con questo [<.>>-]. Questo è un blocco di codice privato SMBF poiché MP di BF è a 0 quando viene avviato il ciclo.

grilletto

A questo punto, ho notato un comportamento strano con SMBF e aveva a che fare con le relazioni tra questi segmenti di codice e la fine del poliglotta.

• Destinazione di salto dell'incidente: ^_^_

• Trigger's Jump destinazione più risposta: X222999

• Risposta di ALGOL68: COprint("65")#s

La risposta di ALGOL ha tokenato un paio di token Incidente all'interno del suo segmento di codice, quindi il codice di ALGOL doveva andare prima del segmento di codice dell'Incidente. ALGOL ha anche causato un problema di allineamento del preludio se è andato per primo nell'ordine, quindi doveva andare secondo o terzo. Nel frattempo SMBF ha avuto un errore inspiegabile quando il codice dell'Incidente è andato per ultimo, quindi l'Incidente ha dovuto andare primo o secondo. Bene, mi sono reso conto che si trattava di un problema logico introduttivo che sembrava irrisolvibile, quindi ho deciso di rendere l'inesplicabile più ... plausibile.

Dopo aver attraversato SMBF ho scoperto che il problema di avere ^ _ ^ _ alla fine era dovuto a Wise. Il codice di Wise ( ~-<~-<~-<<<~-) non è nascosto dietro un ciclo non eseguibile, a differenza della maggior parte dei poliglotti. Ma non ci sono codici di stampa SMBF coinvolti nel codice di Wise. Stava solo cambiando i valori della memoria. Sembrava innocuo. Allora qual era il problema? Era quel maledetto SM di fronte al BF.

Il codice di Wise sta cambiando i caratteri nel codice che sta per essere eseguito, e puoi indovinare qual è il vicino valore ASCII ^? Lo è ]. Wise stava inserendo un terminatore di loop SMBF alla fine del poliglotta, facendo cadere SMBF in un loop infinito. Questo è cattivo mojo.

Dopo aver riflettuto ho preso la soluzione 0 byte al problema e separati destinazione del salto di trigger ( X) dalla sua risposta ( 222999) e si è conclusa il poliglotte così: ~-<~-<~-<<<~-XCOprint("65")#s^_^_2229996#. Funziona solo perché nessun personaggio appare consecutivamente dopo il salto di Trigger che non è la risposta di Trigger.

Avvolgendo

Questi sono tutti i principali cambiamenti in questo round. Ho fatto una piccola modifica per tagliare il tanto discusso cnella riga 1, ma è tutto per modifiche puramente golfistiche.

In bocca al lupo!

Verbale di incidente

#<q>"3"O.sdivenne #<T>"3"O.sperché detokenizing Tanziché qera più efficiente nel bilanciamento

<>{divenne <>{ndper dissociare nde{␊

Metti uno spazio tra }}e +dentro #<]}} +<[<.>>-]>[per staccare }}+più a buon mercato.

2. V (11 byte)

print(1)#i2

Questo programma stampa 1 in Python 3 e 2 in V.

Solo per far rotolare la palla e lanciare la mia lingua preferita nel mix all'inizio. :)

È una risposta molto semplice.

print(1)#

solo così sembra essere un NOP in V. (fortunatamente per me) Quindi i2entra in modalità di inserimento e inserisce un '2'. Puoi provare V online qui

Certo, in pitone

print(1)

stampa '1' e

#i2

è un commento.

20. Preludio, 167 byte

#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

Caratteri ESC letterali nello stesso posto degli invii precedenti (tra #e g, e tra 2e `, nell'ultima riga), perché non è possibile disattivare Vim dalla modalità di inserimento con caratteri stampabili.

Questo programma stampa 20 in Prelude , 19 in Reng (verificabile qui ), 18 in Cardinale , 17 in Julia , 16 in Pyth , 15 in Haystack , 14 in Turtlèd , 13 in Ruby , 12 in Fission , 11 in Befunge-98 , 10 nella Befunge-93 , 9 nella Perl , 8 nella Retina , 7 nella Japt , 6 nella SMBF ,5in Python 2 , 4 in> <> , 3 in Minkolang , 2 in Vim / V , 1 in Python 3 e a partridgein A Pear Tree .

Il codice esistente praticamente si annulla in Prelude, costituito solo da cicli while con argomenti falsi e alcune manipolazioni dello stack su stack di cui non ci interessa. Ancora meglio, c'è un punto nel codice che è un commento in tutte le lingue che li hanno (tra il #e =#del precedente invio). La parte difficile del montaggio di Prelude in questo era generare numeri con un solo stack e senza far saltare il conteggio dei byte. Questo programma usa un loop che aggiunge 45 ad ogni elemento dello stack e lo emette come ASCII, quindi posizionando un 5 sopra un 3 nello stack, otteniamo 20come output. (Ordinariamente, 20 è un numero più facile da produrre rispetto a 19 in Preludio, quindi la risposta 19 pubblicata in realtà mi ha aiutato un po '.)

30. Spazio bianco , 296 byte

#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

␛ rappresenta fughe letterali.

␉ rappresenta le schede letterali.

Questo programma stampa 30 in Whitespace , 29 in Trigger , 28 in Brain-Flak , 27 in Perl 6 , 26 in 05AB1E , 25 in Pip , 24 in Thutu , in Haystack , 14 in Turtlèd , 13 in Ruby , 12 in Fission , 11 in Befunge-98 , 10 in Befunge-93 , 9 in Perl 5 , 8 23 in Hexagony , 22 in Underload , 21 in Nim , 20 in Prelude , 19 a Reng (testato qui ), 18 a Cardinal , 17 a Julia , 16 a Pyth ,15 a Retina , 7 a Japt , 6 a SMBF , 5 a Python 2 , 4 in> <> , 3 in Minkolang , 2 in V / Vim e 1 in Python 3 .

Whitespace è un altro esolang con un set di caratteri limitato. Questo legge solo schede, spazi e feed di riga.

Quindi, una volta eliminati tutti gli elementi che Whitespace non legge, restiamo con il seguente codice:

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

E il codice per l'output 30 è questo:

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

Quindi alle prime 3 righe del codice esistente sono stati assegnati spazi extra alla fine delle righe per soddisfare i requisiti. Si noti che le schede della riga 1 e lo spazio finale si trovano al centro della riga per soddisfare le esigenze di <<>.

Lo spazio della linea 2 è stato modificato in una scheda qui. Questo sembra funzionare in modo identico a uno spazio per i linguaggi 2D, ma visivamente non si allinea più. ¯ \ _ (ツ) _ / ¯

Dopo le istruzioni per l'uscita 30, il gioco è diventato ottenere il resto degli spazi necessari e feed di linea per fare cose inutili e compilare correttamente.

Gli spazi bianchi contengono istruzioni che contrassegnano / vanno a una posizione del codice con un'etichetta che consente un numero arbitrario di schede e spazi, in modo da aiutare a dividere gli spazi della linea lunga. Inoltre, inizia e termina con un avanzamento riga, in modo che ci abbia aiutato ad aumentare alcuni degli avanzamenti riga nelle righe 3-6.

L'ultima riga non può avere un avanzamento di riga senza interrompere Retina, quindi le sue istruzioni sono di eseguire alcune manipolazioni matematiche e di stack arbitrarie.

Ecco il codice completo con spazi, schede e avanzamenti di riga sostituiti con la nostra notazione:

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

Ed ecco una versione commentata solo dello spazio bianco:

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]

Modifiche: Hexagony risulta saltare le schede proprio come gli spazi, contrariamente alla mia affermazione precedente. @ ais523 è stato così gentile da aggiornare @Hexagonizer di Kenney per tenere conto delle fughe e delle schede letterali. Ho dovuto modificarlo per correggere la mia precedente affermazione sul fatto che le schede venivano lette come non operative e per sostituire le fughe letterali .perché il ␛personaggio è più largo degli altri, rendendo l'esagono leggermente disallineato. Qui il link .

E questo è il nostro esadecimale corrente corretto:

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

Alla fine, ho scelto alcuni personaggi inutili, per lo più aggiunti in precedenza per allineare le parentesi Prelude e gli esagoni Hexagony.

Il codice di Nim è tornato a echo 21daecho 5+5+11

Hexagony's #@46è ora#46

Il codice di Hexagony è tornato a /+23!@=da/+23!@

L'allineamento tra parentesi di Prelude è (9) or (13)diventato(9)and(13)

Bene, questo è tutto ciò che ho. Buona fortuna a tutti!

100. brainbool, 2953 byte

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

Punteggio VIP ( stampante a numeri interi versatili ): .002953 (per migliorare, la voce successiva non deve superare i 3042 byte)

Corri giù

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

Verifica

Provalo online! Lingue non disponibili su TIO:

• Japt, 7 online .
• Reng, 19 online .
• Pesce morto ~, 48 locali .
• Moorhens, 60 locali . usa moorhens.py dal ramo v2.0-dev
• Morse, 73 locali
• Archway, 74 locali
• Trefunge-98, 76 locali . Uso-d 3 -v 98 per Trefunge-98.
• Objeck, 83 locali
• zkl, 85 locali
• PingPong, 88 locali
• RunR, 90 locali
• Cood, 91 online
• Set, 93 online
• Emotinomicon, 94 online
• EmojiCoder, 96 online
• Archway2, 98 local Non riesco a testare Archway2 perché non ho il compilatore C corretto, tuttavia stasoid ha confermato che funziona in archway2

Spiegazione

Non riesco a credere che ce l'abbiamo fatta in 100 lingue. Vorrei solo prendere il tempo per ringraziare tutti coloro che sono stati coinvolti in questo processo. È stato un giro divertente e spero di aggiungerne altri 100 con voi ragazzi.

Brainbool è stato nei miei occhi per un po '. Tuttavia, poiché brainbool può produrre solo due numeri, 1e 0non sono stato in grado di aggiungerlo fino ad ora (non ero in giro per 10 e 11).

Brainbool è proprio come brainfuck, tranne che invece di avvolgersi a 256 si avvolge a 2. Brainbool non ha nemmeno un -perché è ridondante con +. Il nostro codice brainbool per l'output 100 è abbastanza semplice:

+.+..

Per mascherare le uscite di Brainfuck aggiungiamo un loop e un segno meno:

+-[.+..]

Ora tutto ciò che serve è trovare un posto dove andare il codice. Il mio posto di scelta è stato il primo +al livello più alto del codice brainfuck alla riga 8. Per sostituire il plus abbiamo aggiunto il nostro codice e uno +-+che funge da +brainfuck e noop in brainbool.

+-[.+..]+-+

Cubix

Ho messo il mio codice davanti alla capsula Cubix facendo spostare uno specchio nel percorso del puntatore. Per risolvere questo problema ho spostato la capsula di un paio di passi in avanti davanti allo specchio offensivo e tutto andava bene.

Sorprendentemente nient'altro ha rotto nemmeno l'incidente noto.

27. Perl 6 , 235 byte

#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

␛ rappresenta un carattere ESC letterale, come al solito.

Questo programma stampa 27 in Perl 6 , 26 in 05AB1E , 25 in Pip , 24 in Thutu , 23 in Esagonia , 22 in Sottocarico , 21 in Nim , 20 in Prelude , 19 in Reng (testato qui ), 18 in Cardinale , 17 in Julia , 16 in Pyth , 15 in Haystack , 14 in Turtlèd , 13 in Ruby ,12 in Fissione , 11 in Befunge-98 , 10 in Befunge-93 , 9 in Perl 5 in Vim / V , 1 in Python 3 e (dato che è Natale)in A Pear Tree ., 8 in Retina , 7 in Japt , 6 in SMBF , 5 in Python 2 , 4 in> <> , 3 in Minkolang , 2a partridge

La sintassi che evidenzia che Stack Exchange produce per questa risposta è completamente sbagliata. #`<è uno dei molti marcatori di commenti multilinea di Perl 6 e termina con #>, quindi l'unico codice che viene effettivamente eseguito in Perl 6 è il molto semplice say 27. Ho scelto questo marcatore di commento particolare perché <>non sono una coppia corrispondente nella maggior parte delle lingue, e quindi i non corrispondenti <non romperanno le lingue, come Retina, che tentano di analizzarlo.

Non sono del tutto sicuro di come funzioni Hexagony. Quando si è rotto, ho cambiato uno dei personaggi che stava usando da a +a a 0per vedere se veniva colpito; scopre che lo era, e risulta che questo ha risolto il programma, ma non sono sicuro del perché (so che si è rotto a causa di un #nella linea di esecuzione, ma non è chiaro il motivo per cui rimuovendo le +correzioni). (Il personaggio in questione è anche analizzato da Thutu, ma per fortuna questo non fa differenza per il funzionamento del programma Thutu, poiché a quel punto del programma, tutto ciò che non è preceduto da un =viene copiato letteralmente nell'opera stringa.) Nota che0and+4 diventato da una riga precedente0and 4, per renderlo più corto di un personaggio dal punto di vista di Hexagony (Hexagony non vede gli spazi); questo per compensare il#|in una riga precedente diventando #`<`|, che è un personaggio più lungo dal punto di vista di Hexagony (perché non vede neanche i backquotes). Si noti che il codice ora è a soli cinque byte dall'espansione della lunghezza del lato Hexagony e dalla rottura di tutto ciò che riguarda l'attuale codice Hexagony. Consiglierei di farlo comunque e rifare semplicemente la sezione Hexagony del codice; probabilmente sarà più facile, piuttosto che più difficile, adattarsi a tutto dopo un'espansione.

Anche alcune altre lingue sono cambiate, principalmente per aggiungere abbastanza robustezza da poter inserire il codice arbitrario nell'ultima riga. $//è un marcatore di commenti in Japt che consente spazi più tardi sulla linea, rendendo il programma aggiunto meno fragile in Japt (nel frattempo,// interrompe se ci sono parentesi di chiusura più avanti nella riga e lo spazio è una sorta di parentesi di chiusura in Japt). Una coppia di spazi è un marcatore di commento in Pip, il che significa che il codice Pip può essere sostanzialmente semplificato qui. Questo significa anche che possiamo semplificare il 05AB1E in modo banale "26. Retina ha bisogno che la quinta linea sia una regex legale che è brava a mettere in relazione le cose (il finale|è quindi per Retina); analizza in modo diverso dalla riga corrispondente nella voce precedente, ma in modo altrettanto adatto. Il cardinale è anche leggermente più semplice rispetto alle voci precedenti, ma questa è solo una pura coincidenza con il modo in cui tutto si allinea verticalmente, e il cambiamento è nel codice che non ha fatto nulla comunque.

Supponendo di ripetere l'Esagonia (probabilmente dovrai farlo), ci sono luoghi sicuri in cui aggiungere il codice su tutte le ultime tre righe: 3in #3]#è solo per Esagonia (e facilmente modificabile); lo spazio tra la #e "sulla riga finale è ignorato dalla stragrande maggioranza delle lingue; e nulla sta davvero analizzando la fine della quinta riga tranne Retina. (Ci sono molti altri posti in cui è possibile aggiungere anche il codice, ma questi sono probabilmente i più convenienti.)

31. SNUSP modulare , 326 byte

Programma

#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

Come al solito, ␛è un letterale personaggio ESC ed ␉è una scheda letterale.

Corri giù

Questo programma stampa 31 in SNUSP modulare, 30 in spazi bianchi, 29 in trigger, 28 in Brain-Flak, 27 in Perl 6, 26 in 05AB1E, 25 in Pip, 24 in Thutu, 23 in Esagonia, 22 in Sottocarico, 21 in Nim , 20 a Preludio, 19 a Reng, 18 a Cardinale, 17 a Julia, 16 a Pyth, 15 a Haystack, 14 a Turtlèd, 13 a Ruby, 12 a Fissione,11 10in Befunge-98, in Python 3.in Befunge-93, 9 in Perl 5, 8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in> <>, 3 in Minkolang, 2 in V / Vim e 1

Verifica

Perché nessun link nella carrellata? Poiché ho lavorato su qualcosa per rendere i test molto più semplici, un driver di test che esegue il programma nella maggior parte delle lingue elencate qui e stampa il risultato. Si spera che ciò renda molto più semplice l'aggiunta di lingue future al poliglotta. Puoi ottenere i risultati di questo programma per 28 delle 31 lingue eseguendo il seguente link TIO (che è un driver di test scritto in un mix di Bash, Perl e A Pear Tree):

Provali online!

Il link produce anche il blocco di codice ␛/ ␉formattato visto sopra e formatta il codice in un esagono per te:

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

Mancano tre lingue: V è troppo lento e Reng e Modular SNUSP non sono installati su TIO. Fortunatamente, tutti e tre hanno interpreti online:

• È possibile testare il programma in V / Vim (output previsto: 2) qui su TIO.
• C'è un interprete Reng online (output previsto: 19) qui .
• C'è un interprete SNUSP modulare online (output previsto: 31) qui . (È pubblicizzato solo come un interprete SNUSP, ma SNUSP modulare è il dialetto che implementa effettivamente, come si vede dai @segni su tutta la pagina.)

Tutti e tre producono l'output previsto, quindi tutti e 31 i programmi sono testati correttamente. (Una cosa che mi preoccupa leggermente è se il programma Whitespace sta terminando correttamente; tuttavia, gli spazi bianchi qui sono identici alla precedente presentazione, quindi sono entrambi giusti o entrambi sbagliati. Se si scopre che il programma sta effettivamente terminando in modo errato, è probabile che entrambi i programmi siano riparabili allo stesso modo.)

Spiegazione

Prima di tutto, l'esagonia, che sembra aver sempre bisogno di essere cambiata. In realtà è molto più semplice di prima; Ho spostato il codice Hexagony subito dopo il codice Trigger, il che significa che è molto vicino alla fine del programma, e la "capsula" Hexagony che stampa 23 ed esce viene eseguita quasi immediatamente. L'ultima riga in genere sembra un buon posto per mettere la capsula, poiché significa che verranno eseguiti meno comandi che potrebbero potenzialmente interrompere l'esagonia.

Tutte le altre modifiche riguardano l'aggiunta del codice SNUSP modulare. La prima cosa da notare è che SNUSP inizia l'esecuzione al primo $carattere del programma, ed è una lingua 2D che esce dopo essere uscito dal bordo del programma, e quindi posizionando il programma SNUSP alla fine della linea lunga (all'interno il codice Thutu, nel momento in cui Thutu accetterà quasi tutto), possiamo garantire che SNUSP non veda alcun codice proveniente da altre lingue e che la maggior parte delle altre lingue non si preoccuperà di SNUSP. Un linguaggio che ha fatto la cura era Perl 6, che è l'analisi parentesi angolari; Ho messo un <codice immediatamente prima del codice SNUSP per renderlo felice (dato che le parentesi erano naturalmente quasi uguali). L'altra lingua che interessa è SMBF;.output sia in SMBF che in SNUSP e non vogliamo creare output extra. Fortunatamente, come visto da SMBF, questo programma è<.>>[…] seguito dal codice SNUSP, ovvero l'elemento nastro corrente è 0. Quindi racchiudere il codice SNUSP tra parentesi quadre "commentarlo" dal punto di vista di SMBF.

Per quanto riguarda il codice stesso, utilizza un noto trucco per scrivere costanti in Modular SNUSP in cui si scrivono molti comandi "start procedure" in una riga e si crea effettivamente una sorta di numero base-Fibonacci. L'idea di base è che +codifica il numero 1; @somma il numero rappresentato dal codice dopo di esso e il numero rappresentato dal codice dopo che ha meno il suo primo carattere; ed =è un no-op (quindi @=raddoppierà il numero alla sua destra). In questo sistema, ho scelto @@@@=+@@@=+#come rappresentazione del numero 48.

C'è un problema qui, però; il metodo standard di scrittura delle costanti in SNUSP lascia il flusso di controllo dietro l'avvio del programma, e con un oneliner (che volevo scrivere qui per ovvi motivi), non c'è modo di cambiare l'IP in modo che punti in qualsiasi direzione se non quella giusta. Questo significa che dovremo in qualche modo far sì che l'IP passi l'intera definizione costante e continui a destra, senza uscire dal programma (cosa #che normalmente farebbe). Per risolvere questo, ho usato con cura una definizione del numero per il quale +era sempre preceduto da =. Ciò significa che posso scrivere il codice per impostare la seconda cella su 48 via @@@@=>+<@@@=>+<#, sicuro nella consapevolezza che nessuno dei >comandi verrà ignorato da un@comando (e quindi manteniamo il controllo del puntatore del nastro). Inoltre, sappiamo che alla fine #la prima cella a nastro avrà ancora il suo valore iniziale. Pertanto, possiamo usare la prima cella a nastro come marcatore per sapere se tornare dalla definizione della procedura o se continuare a destra (ci troviamo dentro un sacco di procedure mentre lo facciamo, ma usciamo dal programma cadendo bordo in modo che non abbia importanza).

Il codice SNUSP finale, quindi, è $+@+-@@@@=>+<@@@=>+<?#>+.--.. Il $segna l'inizio del programma. +@+-imposta il primo elemento nastro su 1 ( ++-, ma una volta che la procedura è iniziata con @restituisce, inizierà l'esecuzione del codice da quel momento in -poi, riportando l'elemento nastro su 0. ?#termina la procedura solo se il primo elemento nastro è diverso da zero; alla fine finiamo dopo #con il secondo elemento a nastro impostato su 50 (48 dalla definizione costante, più 2 tra i due >+<rilevati quando andiamo a destra in seguito). Quindi tutto ciò che dobbiamo fare è >+.--.emettere i codici ASCII 51 ( 3) e 49 ( 1), e cadono dal limite del programma ( ]è una no-op in SNUSP, e /riflette verticalmente il flusso di controllo in modo che scorra dal bordo superiore del programma); questo bit funziona in modo identico a Brainfuck.

11. Befunge 98 , 102 byte

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

stampe:

• 1 in Python 3
• 2 in Vim - L'output richiede un po 'di tempo per qualche motivo ...
• 3 in Minkolang v0.15
• 4 in > <>
• 5 in Python 2
• 6 in SMBF
• 7 in Japt
• 8 a Retina
• 9 in Perl
• 10 in Befunge 93
• 11 in Befunge 98

Ad essere sinceri, non ho idea del perché il codice Vim impieghi 1 minuto per l'output. Inoltre, non ho idea di come funzioni Retina.

Spiegazione:

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

Cose da notare:

• Il 0prossimo al bnon è strettamente necessario nello stato corrente del codice e lo stack è stato cancellato. Può essere rimosso se necessario, ma consente in anticipo altre manipolazioni dello stack come parte di un possibile programma futuro.
• L' _q@è lì come parte di Retina (Non funziona senza di essa, non chiedetemi perché). L'aggiunta di qconsente anche al codice '98 di eseguire tun'operazione, che divide l'IP (insieme a far stampare il programma Retina 8 anziché 7)
• Non _è un semplice >perché ciò rovinerebbe la parte SMBF.

Modifica: ho appena realizzato che _q@probabilmente dovrebbe essere @00(dove 0 può essere ~ qualsiasi carattere) per rendere il programma più flessibile in futuro. Sono troppo pigro (e stanco) per cambiare tutti i collegamenti adesso. Alla fine ci riusciremo ...

Modifica 2: non mi aspettavo altre 6 risposte così velocemente. Immagino che rimanga com'è. Ottimo lavoro a tutti!

35. INTERCAL (C-INTERCAL), 631 byte

#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

␉è una scheda letterale, ␛un carattere letterale ESC; Stack Exchange altererebbe il programma altrimenti. Ti consiglio di copiare il programma dalla casella "input" del link TIO qui sotto, se vuoi lavorare su di esso.

Provali online!

Corri giù

Questo programma stampa 35 in INTERCAL, 34 in Rail, 33 in Incident, 32 in Whirl, 31 in Modular SNUSP, 30 in Whitespace, 29 in Trigger, 28 in Brain-Flak, 27 in Perl 6, 26 in 05AB1E, 25 in Pip , 24 a Thutu, 23 in Hexagony, 22 in sottocarico, 21 in Nim, 20 in Preludio, 19 in Reng, 18 in cardinale, 17 in Julia, 16 in Pyth,15 a Haystack, 14 a Turtlèd, 13 a Ruby, 12 a Fission, 11 a Befunge-98, 10 a Befunge-93, 9 a Perl 5, 8 a Retina, 7 a Japt, 6 a SMBF, 5 a Python 2, 4 in> <>, 3 in Minkolang, 2 in V / Vim e 1 in Python 3.

Verifica

La maggior parte delle lingue sono testate dal driver di test mostrato sopra. Puoi testare Reng qui e SNUSP modulare qui ; producono rispettivamente 19 e 31, come richiesto. Ho provato Incidente localmente sul mio sistema, usando l'interprete ufficiale.

Si noti che ho aggiunto alcune modifiche al driver di prova per facilitare l'individuazione dei caratteri nascosti; vari byte NUL si erano insinuati nell'output del programma in alcune lingue. Ho deciso che questo probabilmente non è un problema, perché a) una vasta gamma di presentazioni lo hanno fatto, e b) gli interpreti di Befunge sembrano aggiungere byte NUL aggiuntivi anche se nulla nel programma implica che (a meno che ho perso qualcosa), quindi deve essere andato avanti per anni ed è probabilmente parte di come funziona l'interprete. (Si noti che le lingue che ancora generano byte NUL - Befunges e Minkolang - non hanno avuto il loro codice modificato per questa presentazione.)

Il precedente invio Rail termina tramite crash, che non è consentito, ma questo è facilmente risolvibile (aggiungendo #a alla fine del programma Rail e regolando Hexagony in modo che corrisponda) e quindi non l'ho considerato un grosso problema. Il Rail in questa soluzione esce correttamente.

Spiegazione

Come funziona il codice INTERCAL

INTERCAL analizza l'intero programma. Tuttavia, gli errori di sintassi sono una cosa di runtime in INTERCAL, non in fase di compilazione, e questo viene spesso utilizzato per creare commenti. (Se un errore di sintassi tenta di eseguire, si bloccherà il programma con errore ICL000I, contrariamente a quanto sostiene erroneamente Wikipedia. Ma se riesci a impedirne l'esecuzione in qualche modo - e INTERCAL ha molti modi per impedire l'esecuzione dei comandi - lo farà abbastanza felicemente non eseguire senza causare un problema.)

Di conseguenza, possiamo impedire la spazzatura alla fine del file in esecuzione semplicemente uscendo dal programma esplicitamente prima (qualcosa che è richiesto comunque, perché INTERCAL si arresta in modo anomalo se la fine del programma viene raggiunta senza un comando di uscita esplicito). Gestire l'avvio del programma è più interessante e sfrutta un bug del parser. Puoi scrivere qualcosa di simile DO %20 READ OUT #8all'output VIIIcon una probabilità del 20% (e altrimenti non fare nulla). Per quanto ne so, C-INTERCAL analizza la% solitaria sulla seconda riga, indicando una probabilità dello 0% per l'esecuzione del primo comando, e quindi finisce per non eseguirla costantemente ogni volta. (Non sono sicuro del perché lo analizzi in questo modo, ma guardando il codice compilato mostra che genera un numero casuale e confrontandolo con 0.)

Ecco come appariva il programma INTERCAL prima di adattarlo al resto del poliglotta:

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

Questo è abbastanza semplice: istanziare un array a 2 elementi; imposta gli elementi su 52 e 32 (decimali) rispettivamente (la codifica di stringa INTERCAL è meglio non menzionata; ho dimenticato come funziona e ho dovuto fare vari esperimenti per capire perché questi numeri codificano 35); leggilo allo standard output; e uscire dal programma. Ho aggiunto un ulteriore PER FAVORE alla fine per terminare l'istruzione GIVE UP, iniziando una nuova istruzione per la spazzatura alla fine del programma, mantenendo limiti accettabili per una conversazione educata. Ovviamente, INTERCAL non sembra del tutto simile nel prodotto finito; Spiegherò perché mentre andiamo.

Sepolto sotto un carico di Ses

Il problema più ovvio con il programma INTERCAL è che contiene la lettera S . Questo è praticamente inevitabile, poiché non c'è modo di indicizzare un array senza usare la lettera in questione. Tuttavia, Sè un comando di output in Underload e non c'è modo di impedirlo analizzando l'intero programma. L'unica soluzione è inserire il codice INTERCAL tra parentesi, equivalente di Underload di una stringa letterale, in modo che non venga eseguito immediatamente.

Tuttavia, abbiamo due ^caratteri alla fine del programma, che eseguono il codice Underload; quindi quegli Ses verranno comunque eseguiti se non facciamo qualcosa al riguardo. Avrei potuto cambiarlo con un altro personaggio, ma ho deciso che era più facile proteggere il codice in modo che diventasse insignificante. asfugge a una stringa in Underload (il che significa che ^, una volta eseguita la stringa, la eliminerà di nuovo semplicemente anziché produrre effetti collaterali dannosi). Ne abbiamo già unoa nel sayusata nel codice Perl 6 (che in questa disposizione del codice, è abbastanza in realtà a causa di modifiche non correlati). Tuttavia, in modo che le persone non debbano fare affidamento su questo, ne ho aggiunto un altroaalla fine della linea (volevo comunque un personaggio lì per rendere visibili quelli che altrimenti sarebbero stati gli spazi finali, e poiché Hexagony aveva bisogno di riempimento così com'è; nota che Hexagony era abbastanza facile da risolvere in questo programma, e in realtà non lo fa necessita di discussioni separate). Quindi il codice Underload è un po 'meno fragile di quanto avrebbe potuto essere.

Preludio a molto lavoro e confusione

Ah, preludio. Normalmente non è la lingua più difficile, ma sicuramente è stata questa volta. Esistono due problemi reali: uno è che l'aggiunta di parentesi extra su una linea molto lunga corre il rischio di disturbare il flusso di controllo del programma Prelude (in quanto creano l'equivalente di un whileloop), e uno è semplicemente il problema di impedirli di allinearli in verticale (che è responsabile della maggior parte dei movimenti casuali di spazi bianchi su linee). Nota che anche Whitespace mi ha dato qualche problema, ma questo programma è equivalente al precedente dal punto di vista di Whitespace, quindi era praticamente un caso di "aggiustare il Preludio senza rompere lo Whitespace".

Non sono troppo sicuro di come il Preludio funzioni effettivamente a questo punto. Ci sono diverse correzioni previste per questo, come lo 0 vicino all'angolo in basso a sinistra, ma chiaramente non funzionano come volevo. (Il codice Julia finì anche per spostarsi in fondo alla riga perché le parentesi nella sua printdichiarazione erano davvero difficili da gestire.) Forse dovremo solo lasciarlo un mistero.

Guasto in un reattore a fissione

Sebbene le modifiche di cui sopra fossero per problemi abbastanza sottili che sono difficili da risolvere, c'è un problema molto più evidente; DOREADOUTcorrisponde al regex R...Oe quindi farà sì che Fission produca output indesiderati sul quarto ciclo, che non è abbastanza tempo per produrre l'output previsto di 12. E INTERCAL ha solo un'istruzione che produce output (a meno che non si consideri l'arresto anomalo come output). Una soluzione a questo è cercare di aggiungere uno spazio tra READe OUT, per darci il tempo di intercettare l'output, ma questo fa arrabbiare lo spazio. Quindi per un po 'ho pensato che questo programma fosse impossibile; R, L, U, E Dsono tutti i punti di ingresso a fissione, e tutti in grado di eseguire codice potenzialmente problematici, e le parole chiave INTERCAL devono essere in maiuscolo.

Tuttavia, c'è una soluzione e abbastanza sorprendente. Come parte di uno sforzo di internazionalizzazione, C-INTERCAL accetta effettivamente parole chiave in più lingue, con supporto sia in inglese che in latino. Non siamo riusciti a evitare Sin questo modo, ma siamo in grado di evitare O; FACè un ottimo sostituto DO, e allo LEGERE EXstesso modo significa la stessa cosa di READ OUT. (Il programma è quindi finito in un mix di inglese e latino, ma va bene; non lo rende quasi meno leggibile.) Come tale, possiamo felicemente far impazzire Fission nell'angolo in basso a destra, e non lasciare che produca alcun produzione. Possiamo cambiare il codice di Fissione reale per finire* modo che termini anziché;, che chiude l'intero programma anziché solo un thread; questo codice viene eseguito abbastanza rapidamente, quindi esce dal programma prima che tutti i punti di ingresso randagi abbiano il tempo di arrecare danni.

Knit 6, Perl 6

Il prossimo problema: i commenti di Perl 6 funzionano abbinando <e >. L'operatore di assegnazione di INTERCAL è <-. Fortunatamente, questo aggiunge parentesi di apertura extra , quindi potrei semplicemente aggiungere alcune parentesi di chiusura per annullarle in una posizione non analizzata nel programma (subito dopo il codice Pip, in questo caso).

Tuttavia, non volevo cambiare il budget degli spazi bianchi del programma, ma spostare il codice Julia (per Prelude) ha finito per aggiungere uno spazio extra all'ultima riga; Ho dovuto rimuoverne uno da qualche parte. Il doppio spazio è un marcatore di commento in Pip, quindi non potrei quasi cambiarlo; l'unica opzione rimanente è lo spazio in say 27. I golfisti di Perl 5 penserebbero immediatamente "bene say+27allora" (unario +è utile sorprendentemente spesso!), Ma sfortunatamente questa non è una sintassi valida di Perl 6.

Ciò che possiamo fare, tuttavia, è passare saydalla sintassi della funzione alla sintassi del metodo. I letterali interi hanno un sacco di metodi, incluso uno per stamparli, quindi 27.sayè un programma perfettamente valido della stessa lunghezza.

Essere quadrato? Non essere lì

Quindi il prossimo numero è che ho aggiunto un extra .al programma. Gli utenti SMBF sapranno che questo è chiaramente un problema in quella lingua, producendo output vaganti (byte NUL in questo caso). Esisteva già un .ultimo programma di output parassita, ma ciò non significa che non avrei dovuto cogliere l'occasione per risolverlo.

L'idea di base qui è quella di creare un ciclo SMBF per commentare le istruzioni offensive. Ciò significa spostare le parentesi quadre. Li ho presi da tutto il codice SNUSP (perché erano lì solo per il bene dell'incidente, e all'incidente non importa dove si trovino nel programma), e ho posizionato la parentesi di apertura all'inizio del codice INTERCAL, e il chiudendo la parentesi appena prima del grilletto (nascondendo così ordinatamente entrambi .).

Sfortunatamente, le parentesi quadre sono significative per Retina; vede […<-#…e dice "non ha senso, non puoi creare quell'intervallo perché <non arriva prima #". Fortunatamente, questo è facilmente risolvibile con una barra rovesciata strategicamente posizionata.

L'incidente al centro del programma

Questa è stata l'ultima risposta, e probabilmente accadrà ripetutamente da ora in poi; varie stringhe si sono verificate casualmente tre volte e si sono spostate attorno al centro del programma dal punto di vista dell'incidente.

Il token più urgente da gestire era 1#, che appare tre volte se si apportano queste modifiche in modo ingenuo: #= >␉1#all'inizio della terza riga __DATA__=1#, e echo 21#. Perché questo è un problema? Perché la 1#terza riga si sovrappone #vsubito dopo e due token sovrapposti non contano nessuno dei due. Ed #vè il token che abbiamo usato per commentare il codice prima che il programma Incidente uscisse! Ho risolto questo problema inserendo un altro 1#molto vicino alla fine del programma (solo tre personaggi lo seguono); nessuna delle lingue che analizzano quella parte del programma fa nulla con esso.

C'erano vari altri token problematici da affrontare. Una coppia erano lettere singole Pe U; Mi sono occupato con questi tramite la modifica di un paio di riempitivo no-ops nel codice Incidente da xa Po U, rispettivamente, dando una quarta copia. La modifica del codice Fission lascia *come segno, ma in particolare, questo viene diviso in modo diverso dal normale, appare due volte prima del codice incidente e solo una volta dopo. Invece di rimuoverlo, quindi, l'ho usato per bilanciare parzialmente il nuovo LEtoken che è apparso nel codice INTERCAL. Questo è sufficiente per riportare il centro del programma su un0ogettone. Naturalmente, è molto probabile che le modifiche al programma possano disturbarlo. (I miei tentativi di ottenere Incidenti su TIO non sono riusciti a causa della mancanza di libdivsufsort lì, quindi sembra che potremmo beneficiare di un nuovo interprete, specialmente in JavaScript, in modo che possa essere eseguito online. Se sei interessato, dai un'occhiata a questo domanda .)

1. Python 3 (8 byte)

print(1)

Questo programma stampa 1 in Python 3.

Iniziare questo con Python 3 perché so che è buono per i poliglotti e può essere preso in un numero di direzioni diverse (inoltre, volevo assicurarmi che la prima risposta fosse in un linguaggio relativamente normale, piuttosto che un assurdo esolang che è difficile da poliglottare con).

10. Befunge , 95 byte

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

C'è un carattere letterale ESC tra je dsull'ultima riga (grr, @ ais523). Non è incluso in questo codice. Per ottenere il codice effettivo, vai al Try it onlinelink.

Questo stampa 1 in Python 3, 2 in Vim, 3 in Minkolang, 4 in <> <, 5 in Python 2, 6 in SMBF, 7 in Japt, 8 in Retina, 9 in Perl, e 10 in Befunge.

Questo codice condivide *con Retina e .con Minkolang e SMBF.

Provalo online

Spiegazione

Programma reale

#v02^
    @
    .
    *



    t
    5
#v02^

L'ultima riga è stata scritta per chiarezza (il parco giochi Befunge è ciclico).

#

Trampolino, salta v

02^

Spingere 0e poi 2in pila e salire.

5t*.@

Push 5, no-op, moltiplica due elementi nello stack ( 2e 5), stampa, termina il programma.

21. Nim (161 byte)

#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

Due <ESC>s, tra 8de tra 2`sull'ultima riga. Si può dire che il mio precedente era stato sballottato in fretta, perché mi sono svegliato questa mattina e mi sono reso conto che avrei potuto prendere un po 'di più. Avevo 152 byte, ma sembra funzionare solo in Perl 5.24.0, quindi nell'interesse della compatibilità con TIO ho mantenuto l'espressione originale per ora.

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

Nota che Nim su ideone.com utilizza la versione 0.11.2, che è un po 'troppo vecchia, poiché questo programma si basa su #[ ... ]#commenti multilinea aggiunti all'inizio del 2016.

Grazie all'interprete Windows di Cardinal, il mio flusso di lavoro è ora composto da due laptop e un Python http.server nel mezzo.

Modifica - altri suggerimenti:

• Il 8L'all'inizio dell'ultima riga è quella di impostare il limite di Retina alle prime 8 partite, altrimenti senza di essa Retina sarebbe uscita 2. Nota che questo significa che la regex della riga finale deve solo corrispondere almeno 8 volte nella seconda ultima riga ora, al contrario di esattamente 8 - durante la mia ingerenza ho modificato Prelude per ottenere Retina giusto, ma alla fine non è stato necessario .
• La citazione non corrispondente alla fine della prima riga è tale che Pyth non si lamenta della sintassi non valida per il resto del codice.
• Se si modifica la seconda riga, potrebbe essere necessario modificare il 6@ per Minkolang, il che fa saltare il puntatore di 6 spazi per atterrare sul ^.
• Ce ne sono un paio []adesso, quindi SMBF deve trovarsi su una cella 0 prima che colpisca [, o alternativa, l'interno deve liberare la cella.

Probabilmente c'è di più nel golf (anche ora vedo uno spazio randagio prima del %cardinale), ma dovrei davvero smettere di giocare a golf nelle prime ore del mattino.

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

#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

␉è una scheda letterale, ␛un carattere letterale ESC; Stack Exchange altererebbe il programma altrimenti. Ti consiglio di copiare il programma dalla casella "input" del link TIO qui sotto, se vuoi lavorare su di esso.

Vuoi saperne di più? Prova la chat di Polygot !

Provalo online!

Punteggio VIP ( Stampante intera versatile numeri ): .008186 (per migliorare, la voce successiva non deve superare i 1151 byte)

Questo programma stampa 51 in Assembly, in Modular SNUSP, 30 in Whitespace, 29 in Trigger, 50 in Bash, 49 in Octave, 48 in Deadfish ~, 47 in Lily, 46 in Cubix, 45 in PicoLisp, 44 in alphuck, 43 in reticolare, 42 in male, 41 in cervello *** , 40 in Minimal-2D, 39 in CoffeeScript, 38 in C, 37 in C ++, 36 in Labyrinth, 35 in INTERCAL, 34 in Rail, 33 in Incident, 32 in Whirl,31 28 in Brain-Flak, 27 in Perl 6, 26 in 05AB1E, 25 in Pip, 24 in Thutu, 23 in esagonia, 22 in sottocarico, 21 in Nim, 20 in Preludio, 19 a Reng, 18 a Cardinale, 17 a Julia, 16 a Pyth, 15 a Haystack, 14 a Turtlèd, 13 a Ruby, 12 a Fission, 11 a Befunge-98,10 in Befunge-93, 9 in Perl 5, 8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in> <>, 3 in Minkolang, 2 in V / Vim e 1 in Python 3.

Verifica

La maggior parte delle lingue sono testate dal driver di test mostrato sopra.

• Reng può essere testato all'uscita 19 qui .

• Modulare SNUSP può essere testato per uscita 31 qui .

• La forma del cubo di Cubix visualizzata qui

• L'incidente viene verificato mantenendo i token bilanciati come descritto nelle risposte precedenti.

• Per Deadfish ~, può essere testato per produrre 48 con questo . Nota che Deadfish ~ prende il poliglotta per essere alimentato con stdin, ma e stampa un numero di >>prompt sullo standard output, che sono inevitabili conseguenze dell'esecuzione di qualsiasi programma Deadfish ~.

• L'assemblaggio può essere testato sull'uscita 51 qui

Grazie e complimenti

Quando la risposta 50-in-1-k di @ ais523 è caduta 2 settimane fa, una lacrima mi è scesa sulla guancia. Era troppo bello Ed era a Bash. Era troppo perfetto.

Mi sono rivolto a mia moglie e ho detto "Penso che il poliglotta sia finito", sentendo un immenso orgoglio.

Si voltò a guardarmi negli occhi, si fermò un momento e disse: "Bene. Ora porta fuori la spazzatura. "

Ciò che intendeva dire era che provava profonda gioia per me e i miei amici di Internet. Grazie e complimenti a tutti.

Spiegazione del montaggio

Nei giorni che seguirono, la mia mente continuava a vagare per qualcosa che @ ais523 disse nella chat poliglotta poco prima di pubblicare Bash. Ha sottolineato che alcuni tipi di assemblaggio utilizzano #commenti di riga basati e /*bloccano i commenti. Bene, mi è bastato perdere lentamente la testa per le prossime 2 settimane.

Esiste una sorta di sfida implicita nei poliglotti per includere lingue legittime. Sto usando il termine legittimo qui in modo molto approssimativo, ma penso che tutti possiamo capire cosa sto ottenendo. Una cosa è includere Brainf ***, ma un'altra cosa è includere artisti del calibro di Mathlab o R. Assembly rientra sicuramente in quest'ultima categoria, e la mia mente non poteva lasciarlo andare. Ma non sapevo nulla dell'Assemblea, quindi questa è stata una battaglia in salita.

Dopo aver sbattuto la testa contro il problema per un po ', cercando un modo per far coesistere Assembly e C / C ++, ho scoperto che questa è la documentazione per l'assemblatore GNU:

Per essere compatibili con gli assemblatori passati, le linee che iniziano con '#' hanno un'interpretazione speciale. Seguire '#' dovrebbe essere un'espressione assoluta (vedi Espressioni): il numero di riga logica della riga successiva. Quindi è consentita una stringa (vedi Stringhe): se presente è un nuovo nome di file logico. Il resto della linea, se presente, dovrebbe essere uno spazio bianco.

Ho notato che questo è abbastanza simile alla nostra direttiva pre-processore per C / C ++ nella riga 1 del poliglotta. Dopo alcuni tentativi ed errori ho scoperto che #1 “bla” 1//*avrebbe inserito un commento di blocco solo per Assembly.

E così fu creato un poliglotta.

Dopo aver risolto i maggiori problemi di blocco, ho iniziato a giocare a golf con questo esempio di ciao mondo.

.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

Credito dell'autore principale

In realtà ho mentito un minuto fa, la prima versione del codice Assembly che ho usato era nella sintassi AT&T, che è uno dei due rami sintattici di Assembly. Uno degli elementi principali della sintassi AT&T è che i riferimenti ai registri utilizzano un %prefisso e questo è un problema per il poliglotta. Il cardinale usa %come origine puntatore, quindi se ne avessimo disseminato un %po ', sarebbe come una seconda reazione di Fissione.

L'altro ramo sintattico, che non utilizza %come prefisso di registro, si chiama sintassi Intel. L'exploit che stiamo usando nel poliglotta per superare la prima riga e inserire un commento di blocco è nell'assemblatore GNU (GAS o AS in breve). AS ha la felice caratteristica di consentire entrambi i rami sintattici. Devi solo dichiarare che vuoi usare la sintassi Intel, che sta accadendo sulla riga 1 del codice assembly.

Assembly utilizza registri, che sono un numero limitato di posizioni di memoria letteralmente posizionate sulla CPU per la velocità di accesso. Questo non è unico per Assembly oltre al fatto che il loro uso non è sottratto alla preoccupazione dello sviluppatore.

Esistono diversi tipi di registri che vengono utilizzati per scopi diversi. Da Wikipedia:

• AX moltiplicare / dividere, caricare le stringhe e memorizzare

• Conteggio CX per operazioni su stringa e turni

• Indirizzo della porta DX per IN e OUT

• Registro indice BX per MOVE

• SP punta in cima allo stack

• BP punta alla base del telaio dello stack

• SI punta a una sorgente nelle operazioni di flusso

• DI punta a una destinazione nelle operazioni di flusso

AX è utilizzato nella linea della funzione _start qui: mov rax, 1. La rin raxindica che la memoria è di 64 bit. Se lo scambiassimo con un e, ciò indicherebbe una memoria a 32 bit, che è totalmente valida per un processore a 64 bit. Non useremmo solo la metà superiore della memoria disponibile. Per indicare la memoria a 16 bit, basta usare ax, il che va bene per noi perché stiamo solo stampando numeri interi. Quindi possiamo giocare a golf di pochi byte cambiando tutti i riferimenti di registro a 16 bit.

Ok, non tutti i riferimenti al registro potrebbero far cadere r. mov rsi, OFFSET FLAT:msg. Se hai familiarità con Assembly, ma non con questa affermazione, è perché questo era univoco per AS. Almeno, quello che ho ricavato da questo , che mi ha aiutato a rendere la dichiarazione giustalea rsi,m .

Dopo questo, ho esperienziale scoperto che avrei potuto battere _start:fino a solo _pe tagliare .global _startdel tutto con solo un avviso. In secondo luogo, è msg:stato ridotto a una sola variabile di carattere p:. Ho scelto psia la variabile stringa che la funzione iniziale per compensare parte sdell'Assemblea aggiunta a beneficio di Alphuck.

Quindi, inserisco ;per delimitare le istruzioni per metterle tutte su una riga. Questo serve principalmente per evitare di trascinare eccessivamente #//i messaggi su ogni linea a beneficio di Thutu. Inoltre, ho notato che il nostro assemblatore non appariva sensibile al maiuscolo / minuscolo, quindi ho semplicemente inserito caratteri maiuscoli o minuscoli per evitare uno squilibrio incidente.

Questo golf ci ha portato a:

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

Dopo tutto questo, Japt e Underload sono stati l'unico problema dei bambini in questa risposta. Japt aveva un po 'di manzo con l' *aggiunta nella riga 1, ma sembrava essere risolto tornando alla puts(p);riga dalla risposta C ++. Ho finito per lanciare anche un (in questa linea e poi chiuderlo sulla linea di Octive. Questo è stato così Underload avrebbe smesso di sefaulting. Un trattamento simile è stato avuto sulla linea 1 da aggiungere al *lì.

Questo è stato sufficiente per soddisfare i requisiti di byte di questa sfida. In realtà ho verificato questo producendo questa versione del poliglotta. Ma volevo tentare di migliorare anche il punteggio VIP, se possibile. E dato che avevo soddisfatto tutti i requisiti della sfida, mi sono sentito bene nel collaborare a golf nel codice. Così mi sono fermato alla chat di poliglotta per cercare aiuto nel golf.

Dobbiamo andare più a fondo

@ ais523 ha dimostrato una tecnica per passare le istruzioni all'assemblatore come codice macchina con questa affermazione.

.text;.long 2298589328,898451655,12,178790,1018168591,84934449,12597 Il codice macchina è una serie di istruzioni numeriche eseguite direttamente dalla CPU che possono essere rappresentate in decimale, esadecimale o ottale. Per i nostri scopi il decimale è il più breve da allora (hex richiede un lead 0xper rappresentare). La .longdichiarazione qui sta facendo la dichiarazione che ciò che segue è una serie di istruzioni decimali di codice macchina.

Bene, ho anche dato un'occhiata a questa affermazione per vedere cosa avrebbe permesso l'assemblatore e ho apportato un paio di modifiche. Innanzitutto, ho scoperto che posso rimuovere .text;tutti insieme, con solo problemi di avvertenza, il che è stato un risparmio di byte piuttosto venduto. Poi poco dopo ho anche trovato questa affermazione nella documentazione delle specifiche AS

.long è uguale a .int

Freddo. Quindi, possiamo fare questo scambio per un byte veloce. Ora il nostro assembly, ma in realtà il codice macchina, è stato ridotto a questo:

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

Anche se va bene, è abbastanza difficile lavorare direttamente con il codice macchina e volevo almeno vedere come fare tutte le traduzioni. Quindi, idealmente, vorremmo separare il codice macchina in assembly. Il modo più semplice per farlo è prendere un dump di oggetti, che @ ais523 mi ha dimostrato con questo frammento di codice.

Ecco il frammento di codice.

Ed ecco solo l'Assemblea.

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)

Quel collegamento mostra anche alcuni numeri esadecimali di 2 caratteri lungo ogni linea di assemblaggio. Quelli corrispondono alle istruzioni decimali. Ad esempio, se si mette 2298589328in questo decimali al convertitore esadecimale, si ottiene 8901B090indietro. E se guardi da vicino, queste sono le prime 4 istruzioni esadecimali dal dump dell'oggetto (in ordine inverso).

Da quello che posso dire, gli insiemi di 4 numeri esadecimali sono sempre usati per convertire in decimali e il trucco di risparmio di byte principale che viene usato qui è quello di strutturare l'assemblaggio in modo che gli ultimi numeri esadecimali nei nostri 4 insiemi siano 00. Questi poi trasformeranno agli zeri iniziali quando li inseriamo .intnell'istruzione che sono stati semplicemente omessi.

Questo è ciò che sta accadendo 12nell'affermazione. Questo è nella parte esadecimale del dump dell'oggetto 0c 00 00 00.

Questo è quanto la mia comprensione dell'Assemblea è arrivata in 2 settimane. Che corso intensivo!

Incidente

L'incidente è stato una soluzione più difficile nell'implementazione più corta dell'assemblaggio perché ha pesato i token poliglotta molto più pesanti verso l'alto. Ecco il rapporto sugli incidenti.

• ! nella riga 2 viene disattivato !

• Il primo EAsulla linea INTERCAL si stacca da solo

• L'ultimo spazio sulla penultima riga determina il token spazio-spazio.

• 85 sull'ultima riga si stacca

• Il Rin si #<R>"3"O.disintossicaR

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

• 16 sull'ultima riga si stacca

• 89 sull'ultima riga si simbolizza da solo

Cardinale

Mi sono appena reso conto di aver apportato una modifica al cardinale che avevo dimenticato di documentare. Ho passato un po 'di tempo a cercare i modi per salvare i byte e ho deciso di imparare il cardinale. Dopo un po 'di tempo con la documentazione, ho visto questa riga.

= copia il valore attivo del puntatore nel suo valore inattivo.

Questo non era un trucco usato nel poliglotta. La vecchia soluzione includeva queste istruzioni: `++ ~ * t

++ incrimenti fino a 2.

~ cambia lo stack attivo

* aggiunge le pile.

Mi sono reso conto che si ~*poteva ottenere solo con le =istruzioni, quindi ho rielaborato la soluzione per eliminare alcuni inutili scambi di stack e aggiungere questo piccolo risparmio di byte.

6. SMBF , 45 byte

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

Provalo online

Questo programma stampa 1 in Python 3, 2 in V, 3 in Minkolang v0.15, 4 in> <>, 5 in Python 2 e 6 in SMBF.

Utilizza SMBF (aka Brainfuck automodificante) <++++<>.. Il puntatore viene spostato a sinistra (sull'ultimo carattere del codice sorgente) e la cella viene incrementata quattro volte, quindi stampata.

13. Ruby (129 byte)

#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

Nota il Esccarattere letterale nell'ultima riga tra il jed , come da ais523 Perl risposta s'.

Provalo online!

Questo stampa 1 in Python 3, 2 in Vim, 3 in Minkolang, 4 in <> <, 5 in Python 2, 6 in SMBF, 7 in Japt, 8 in Retina, 9 in Perl, 10 in Befunge, 11 in Befunge- 98, 12 in Fissione e 13 in Rubino.

Solo una piccola modifica alla printdichiarazione esistente per abusare del fatto che 0è vero in Ruby. Ho dovuto aggiungere degli spazi alle altre istruzioni per farlo analizzare correttamente.

15. Haystack (141 byte)

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

Nota: c'è un ESCafter onella terza riga e after jnell'ultima riga

Questo stampa 1 in Python 3 , 2 in Vim, 3 in Minkolang, 4 in <> <, 5 in Python 2 , 6 in SMBF, 7 in Japt, 8 in Retina, 9 in Perl, 10 in Befunge, 11 in Befunge- 98 , 12 a Fissione, 13 a Ruby, 14 a Turtlèd e 15 a Haystack.

Provalo online!

Spiegazione

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

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

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

C'è un carattere letterale ESC nel codice effettivo tra je d; è stato sostituito con un ␛ qui per visibilità.

Stampa 1 in Python 3 , 2 in Vim (testato localmente, ma ecco un link per il linguaggio molto simile V), 3 in Minkolang , 4 in <> < , 5 in Python 2 , 6 in SMBF , 7 in Japt , 8 a Retina e 9 in Perl .

Scopriamo altre lingue exoteriche, abusando dell'aritmetica che funziona in modo diverso in lingue diverse. ( Noneè falso in Python ma vero in Perl, e and/or catene funzionano allo stesso modo in entrambe le lingue.)

Oltre a Python, ho anche dovuto modificare il codice VIM. Invece di trasformarlo in una serie di operazioni non consentite, ho semplicemente lasciato che inserisse la spazzatura, quindi alla fine ho eliminato di nuovo la spazzatura.

36. Labyrinth , 647 byte

#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

␉è una scheda letterale, ␛un carattere letterale ESC; Stack Exchange altererebbe il programma altrimenti. Ti consiglio di copiare il programma dalla casella "input" del link TIO qui sotto, se vuoi lavorare su di esso.

Provali online!

Corri giù

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

Verifica

La maggior parte delle lingue sono testate dal driver di test mostrato sopra. Puoi testare Reng qui e SNUSP modulare qui ; producono rispettivamente 19 e 31. @ ais523 ha aiutato il debug e la correzione del codice incidente, che ora funziona.

Come funziona Labyrinth

Labyrinth inizia spostando alcune colonne nella sorgente di un po ', ma dopo alcuni passi il puntatore arriva a dove si Ntrova sulla 2a linea (inizialmente, quando il puntatore arriva lì non è più unN lì), spostandosi a destra , con uno 0 in cima alla pila. Quindi, semplicemente spinge e stampa un 36 e termina con36!@

Le cose che ho fatto si sono rotte

Sapevo di voler aggiungere Labyrinth, in quanto è uno dei pochi esolang che conosco un po '. Con il suo debugger, ho scoperto che cambiando l'8 nell'ultima riga in uno 0, Labyrinth non si è bloccato in un ciclo infinito e, stranamente, sembrava che nient'altro si rompesse. Da lì ho appena scaricato il comando raw 36 e l'output di cui avevo bisogno, e quelli hanno portato convenientemente a un@ a terminare le cose.

Quindi, è stato per riparare ciò che ho rotto: Minkolang, Cardinale ed Esagonia.

La !stava facendo Minko saltare il carattere successivo, che aveva bisogno di interrompere, quindi ho solo aggiunto un extra @. Fin qui tutto bene.

Il cambio di lunghezza della seconda riga ha fatto perdere a Cardinal la sua dichiarazione di output. Cercare di aggiungere un extra .sulla prima riga ha fatto perdere la testa a Prelude (non ho idea del perché, onestamente), quindi ho scelto un metodo diverso e l'ho lasciato cadere nella seconda riga. Ciò ha inavvertitamente generato un terzo indicatore cardinale, quindi ho riempito le cose con una ?(non una scelta necessaria, solo la prima cosa che ho scoperto che ha risolto sia Fission che Cardinal).

Per fortuna, l'esagonia è stata una soluzione relativamente semplice, ho appena inserito una serie di lettere in modo che il puntatore trovasse il codice. Ho pensato che l'alfabeto non avrebbe dovuto apparire prima e non avrebbe causato problemi con Incidente. Questo è anche quando ho capito che non avevo testato Incidente. Grazie a @ ai523, ho scoperto che avevo solo bisogno di un punto esclamativo aggiuntivo, quindi la estringa dell'alfabeto è stata cambiata in a !.

I punteggi di The versatile integer printer

Solo per i calci e l'interruzione del commento di @Stewie Griffin sulla domanda, ecco uno snippet che mostra come ogni risposta avrebbe segnato se fosse stata inserita in "La stampante versatile per numeri interi".

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

#  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

␉è una scheda letterale, ␛un carattere letterale ESC; Stack Exchange altererebbe il programma altrimenti. Ti consiglio di copiare il programma dalla casella "input" del link TIO qui sotto, se vuoi lavorare su di esso.

Provalo online!

Punteggio VIP (stampante a numeri interi versatili): 0,01329

Corri giù

Questo programma stampa 41 in Brainf ***, 40 in Minimal-2D, 39 in CoffeeScript, 38 in C, 37 in C ++, 36 in Labyrinth, 35 in INTERCAL, 34 in Rail, 33 in Incident, 32 in Whirl, 31 in SNUSP modulare, 30 in spazi bianchi, 29 in trigger, 28 in Brain-Flak, 27 in Perl 6, 26 in 05AB1E, 25 in Pip, 24 in Thutu, 23 in Hexagony, 22 in Sottocarico,21 in Nim, 20 a Prelude, 19 a Reng, 18 a Cardinal, 17 a Julia, 16 a Pyth, 15 a Haystack, 14 a Turtlèd, 13 a Ruby, 12 a Fission, 11 a Befunge-98, 10 a Befunge-93 , 9 in Perl 5, 8 in Retina, 7 in Japt, 6 in SMBF, 5 in Python 2, 4 in> <>, 3 in Minkolang, 2 in V / Vim e 1 in Python 3.

Verifica

La maggior parte delle lingue sono testate dal driver di test mostrato sopra. Puoi testare Reng qui e SNUSP modularequi ; producono rispettivamente 19 e 31, come richiesto.

Il driver di test è stato aggiornato per includere il tokenizer, finalmente. Tutto il codice C viene archiviato come argomento dal punto di vista di Bash Script. Ho anche modificato l'output per avvolgere orizzontalmente con uno spazio finale dopo ogni token anziché emettere in verticale. Questa era solo la mia preferenza, per farla corrispondere all'output degli spazi bianchi. Ma chiunque altro può cambiarlo se ha la sensazione che sia troppo confuso.

Ho anche apportato una regolazione al Test Driver per gestire la spaziatura delle colonne per il carattere UFT8 di Turtlèd nella carrellata. Quel disallineamento mi stava facendo impazzire! La "correzione" è piuttosto hack-ish poiché cerca solo una è e cambia la larghezza della colonna per quel caso, ma ottiene il lavoro fatto.

Spiegazione

Prima di tutto, voglio dire quanto è fantastica la versatile stampante a numeri interi di @ SnoringFrog snippet di codice di Rundown del punteggio di Rundown della dell'ultimo post. Ho calcolato le risposte prima di postare per un po ', e questo mi ha ispirato a mantenerlo piccolo. Penso che alla fine possiamo battere la risposta di @ sp3000.

Così ho iniziato a lavorare su questa risposta provando a cercare quello che potevo e ho avuto abbastanza successo. Ho anche avuto una risposta in un'altra lingua con un numero totale di byte inferiore a # 40. Ma mentre cercavo di giocare a golf in Minimal-2D, ho dovuto imparare BF in modo da poter lavorare meglio con i suoi derivati ​​e nel processo ho trovato il record di @ Primo che ha battuto Hello, World! . Mi sono innamorato dell'eleganza.

Si è scoperto che Minimal-2D non era abbastanza efficiente da utilizzare la tecnica di inizializzazione del nastro utilizzata da @Primo, ma ora sono dell'opinione che probabilmente sarebbe comunque troppo pesante. Dopo tutto, stiamo solo provando a stampare un numero intero. Ma @Primo mi ha inviato lungo il percorso per imparare a moltiplicare in BF, che ho portato al codice Minimal-2D.

Quindi, dopo tutto questo, ho riletto il commento di @ SnoringFrog su come includere BF e ho capito che non solo potevo farlo, ma avrei potuto usare gran parte del codice Minimal-2D che avevo inserito nella risposta BF. Quindi ho scavato per rispondere con BF, ed eccoci qui.

Un'altra cosa prima di entrare nei dettagli. Ci sono state un paio di modifiche che ho fatto per motivi non legati al golf. Innanzitutto, ho spostato la maggior parte del codice @SnoringFrog aggiunto appena sotto i linguaggi 2D nelle prime righe. Per me, è una mossa strategica a lungo termine impedire ai lang 2D di attraversare il centro del poliglotta per prevenire, ove possibile, futuri bug. Il byte byte era basso per questa mossa, quindi ci sono andato.

In secondo luogo, durante i vari ri-fattori ho appreso che Begunges e Minkolang hanno prodotto uno spazio finale dopo output numerici e che questa era la causa dei byte null che abbiamo visto nel Test Driver per queste lingue. Ho risolto questi problemi emettendo il valore dello stack come codice ASCII (che non includeva la funzione spazio finale), anziché il valore direttamente. C'è stato un piccolo byte hit anche per questa modifica, ma ora l'output del Test Driver è così uniforme. Come non potrei?

SM / BF

Esaminiamo rapidamente le basi. Questi sono gli unici comandi validi per SMBF e 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

Entrambe le lingue hanno un nastro di memoria in cui i valori sono memorizzati e modificati. L'unica differenza di SMBF è che qualsiasi codice in esecuzione viene anche memorizzato sul nastro di memoria a sinistra del punto iniziale. Come sottolineato da @SnoringFrog, fare in modo che SMBF e BF producano risultati differenti dipende dal movimento del puntatore di memoria a sinistra dell'origine. Nell'interprete BF di Tio, il puntatore di memoria è in grado di spostarsi a sinistra dell'origine e troverà 0 anziché i codici ascii di Polyglot che SMBF vede. Ecco un esempio che può essere eseguito sia in SMBF che in BF per esemplificare la differenza.

All'inizio del poliglotta, i Befunges richiedono che nella >seconda fila vengano eseguiti fino al completamento e Perl6 richiede che ciascuno >sia preceduto da un <. Quindi SM / BF inizia con il <>lasciare il puntatore di memoria all'origine, quindi preme a [che salta alcuni caratteri offensivi per entrambe le lingue ]sulla sesta riga.

Successivamente, incrementiamo la cella di memoria di origine per entrambe le lingue e spostiamo il puntatore di memoria verso sinistra con +<. (Per convenzione conversazionale, chiameremo la cella di memoria di origine come cella 0, celle a destra dell'origine 1, 2, ... E celle a sinistra -1, -2, ...). La cella -1 contiene il codice asci dell'ultimo carattere nel poliglotta in SMBF e 0 in BF, quindi quando [si incontra il successivo , solo BF passa al successivo ]mentre SMBF passa nel codice.

Mentre SMBF attraversa [.>-], stampa i 6 trovati alla fine del poliglotta e quindi sposta il puntatore della memoria sulla cella 0, riportando il suo valore su zero per uscire da ]. Per rivedere, i nastri in questa pinta sono: le cellule negative di SMBF contengono il poliglotta, ed è 0 e le celle positive contengono zero. Le celle negative e positive di BF contengono zero mentre la sua cella di origine contiene 1.

Successivamente >sposta SMBF nella cella 1 e BF nella cella 0 consentendo a BF di inserire il suo blocco di codice privato: [<+++++[>++++++++++<-][<<<]>+.---.>](Ho rimosso i caratteri non BF da questo). Qui, torniamo alla cella -1 e inizializziamo la nostra variabile di controllo del ciclo (cella -1) su un valore di 5. Quindi entriamo nel ciclo in cui aggiungiamo 10 alla cella 0 e diminuiamo la cella -1 cinque volte prima di uscire dal ciclo in cui indicheremo la cella -1 con un valore di 0.

Successivamente ci imbattiamo [<<<]indicando uno zero, quindi BF non passa attraverso questo. Lo scopo qui è quello di bilanciare un numero di >"precedenti <" in modo che Perl6 non si guasti.

A questo punto la cella 0 è valutata 51. Il valore ascii di 4 è 52, quindi spostiamo il puntatore sulla cella 0 aggiungi 1, quindi stampiamo il valore. E infine, riduciamo la cella 0 al carattere ascii 1 e stampiamo di nuovo prima di impostare il puntatore di memoria sulla cella 1 (valore 0) per uscire oltre ].

SMBF e BF colpiscono entrambi l'ultimo [alla riga 8 successiva mentre entrambi poggiano su un valore 0. Quindi entrambi saltano oltre il restante codice Minimal-2D fino a quando non ]viene rilevato sulla riga 11. Ma questa è di breve durata perché la riga 12 inizia con un'altra [che porta entrambe le lingue quasi alla fine del poliglotta dove non vengono incontrate ulteriori istruzioni.

refactors

Minimal-2D

La riscrittura di Minimal-2D doveva principalmente salvare alcuni byte in un modo simile al trucco di moltiplicazione di BF. Minimal-2D tuttavia non ha i caratteri [e ]per il controllo del loop. Invece ha questi comandi:

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

Questi possono essere usati per produrre la stessa struttura logica, sebbene in un maniero 2D, come quella di BF. Ad esempio, BF ++++++[>++++++<-]>.è equivalente a questo in Minimal-2D.

Ecco una versione semplificata del codice Minimal-2D nel poliglotta, con tutto il codice estraneo rimosso e tutti i caratteri che trattengono il posto vengono sostituiti con #.

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

La Driga 1 invia il puntatore dell'istruzione alla Lriga 8 del poliglotta che invia il puntatore a sinistra. Qui impostiamo la variabile di controllo del ciclo (cella 0) su 7, spostiamo il puntatore di memoria sulla cella 1 ed entriamo in un ciclo. Nel ciclo, aggiungiamo 3 alla cella 1, diminuiamo la cella 0 quindi controlliamo se il valore della cella 0 è ancora zero. In caso contrario, aggiungiamo altri 8 alla cella 1, quindi diminuiamo e ricontrolliamo. Il risultato di questo loop è il valore della cella 1 impostato su 51 alla fine del loop (6 * 8 + 3).

Usciamo dal ciclo saltando il U, spostando il puntatore di memoria sulla cella 1 e scendendo poi a destra sulla linea 11 del poliglotta. E infine, incrementiamo fino al valore ascii per 4, quindi diminuiamo fino al valore ascii per 0 prima di correre verso destra per terminare il programma.

Retina

Retina aveva molti requisiti con cui era difficile lavorare per tutti i derivati ​​BF. Non gli piacciono quelli consecutivi +o non corrispondenti ()o []. Ma questi sono davvero solo requisiti per ogni altra linea, quindi gran parte del lavoro per BF, SMBF e Minimal-2D ruotava attorno a mettere la maggior parte del codice su linee pari.

L'unico byte assegnato esclusivamente a Retina è però |alla fine della riga 11. Per citare @ ais523 “la maggior parte delle regex che terminano con | corrisponderà a qualsiasi cosa ". Senza questo, Retina restituisce 0. Perché questo lo risolve, non lo so. Non ho dovuto scavare troppo in Retina, probabilmente perché ho evitato la lunga fila. Ma come Preludio, ho scoperto che non ho bisogno di capirlo tanto quanto ho bisogno di capire come eseguire il debug, che in questo caso consisteva principalmente nell'eliminare le linee (in multipli di 2) fino a quando non ho trovato la linea questo sta causando la sua rottura. Ho indovinato questa correzione sulla base del commento di @ ais523, e sono stato premiato. Sono troppo figo per la scuola, immagino.

Cardinale

Mi è capitato di apprezzare il posizionamento di @ SnoringFrog di Minimal-2D rispetto al codice di Cardinal. È una buona posizione considerando che Cardinal non disturba la Retina e sembra consentire un intreccio con Minimal-2D. Quindi, quando ho deciso di trapiantare Minimal-2D fino alla terra 2D, ho portato Cardinal per la corsa. Ci sono stati un paio di cambiamenti estetici a Cardinale però. In primo luogo, ho lanciato >quasi all'inizio della sua dichiarazione #p x%>~~~+ +~*ttt*.xper Minimal-2D per cambiare i puntatori di memoria all'interno del suo loop / Second, ho spostato tutto di un carattere a destra per dare spazio a Minimal-2D per uscire dal suo loop con grazia. In pquesta puntura è per questa imbottitura del personaggio.

Befunge / 98

I Befung sono in realtà il punto in cui ho iniziato a cercare di giocare a golf sul poliglotta, dal momento che il refattore C ++ ha cambiato tutto l'altro codice lang 2D, tranne questo. Nel tentativo di imparare WTF stava succedendo in questo codice, ho trovato questo nella documentazione di Begunge:

Il .comando aprirà un valore dallo stack e lo emetterà come un numero intero decimale, seguito da uno spazio , un po 'come Forth. ,aprirà un valore, lo interpreterà come il valore ASCII di un carattere e produrrà quel carattere ( non seguito da uno spazio ) .

Santa Talpa! Possiamo ripulire i byte null sull'output. Dopodiché, si trattava solo di capire come inserire i valori ASC più grandi e di separare il codice. Befunge-98 aveva un codice di salto che gli ;diceva di saltare [77*,68*,@dentro ;[77*,68*,@;'1,'1,q, il che ci ha dato la segregazione.

Befunge-98 aveva anche un comando ( ') per prendere il codice ASCII del carattere successivo. Quindi, '1,prende il codice asci codice per il personaggio 1, lo mette nello stack e quindi stampa il carattere ASCII per il valore più alto nello stack con ,. Devo farlo due volte per stampare 11 e rilasciare a qper uscire con grazia.

Befunge vera e propria è un po 'meno conveniente, ma solo giusto. Qui dobbiamo eseguire un calcolo per mettere il codice desiderato nello stack. Fortunatamente, i nostri codici sono stati facilmente moltiplicati con 7 * 7 e 6 * 8 prima dello stesso comando di output ,. Quindi uscimmo da Befunge @prima che il codice di suo fratello maggiore contaminasse l'output.

Minkolang

Dopo aver trovato una correzione per gli spazi finali del Befunge, mi sono piuttosto entusiasta all'idea di trovare anche una correzione Minkolang e la documentazione di Minkolang affermava che il comando di output che era stato utilizzato fino a quel momento funzionava allo stesso modo dell'interprete Befunge. Omi è capitato di essere documentato come un altro comando di output, che non è stato descritto come condivisione di questo Begunge-ness, quindi ho appena fatto uno scatto al buio e ho provato a emettere la stringa "3". Vittoria impeccabile.

> <>

Una delle prime cose che ho visto quando ho spostato il codice Minimal-2D è stata la verifica che potevo spostare> <> insieme ad esso. Se avessi avuto a che fare con il transversalismo poliglotta 2D, avrei avuto a che fare con tutte le trasgressioni. Fondamentalmente ho tentato la fortuna di trovare la soluzione di mettere ;n4 alla fine della linea 1 e di spostarmi \Dindietro nella riga 1. A proposito, non sapevo che> <> potesse essere indirizzato verso il basso prima della risposta 40 poiché era così ben contenuto . Mi piacerebbe pensare che questo potrebbe essere usato in seguito per divergere> <> da un'altra lingua simile.

Perl6

Ho parlato di alcuni dei <>problemi di bilanciamento di Perl6 altrove in questa risposta, quindi non ci riproverò. Ma voglio sottolineare che sono passato #>27.say#alla penultima riga. Questo non ha uno scopo funzionale in questa risposta. In realtà ho fatto questa mossa per soddisfare una risposta diversa che ho finito per non usare in questo round. Ho deciso di lasciarlo solo perché ho intenzione di pubblicare quella risposta alla mia prossima opportunità e non volevo preoccuparmi di annullare e rifarlo.

Correzioni di bug

05as1e

05as1e sicuramente non mi è piaciuto il nuovo codice Begunge tanto quanto la vecchia versione. Suppongo che sia la ,s poiché è l'unico personaggio rivoluzionario. In ogni caso, "per nascondere i comandi offensivi , ho dovuto spostarmi indietro nella seconda riga e sapevo che "doveva andare prima del percorso del codice Befunge poiché "era un sì-op in entrambe le lingue. (Posso solo inventare termini come yes-op giusto?) La 2-dimensionalità della riga 2 è piuttosto rigida, ma sono stato in grado di spostare il <precedente al percorso del codice di Begunge con il ". L' <però era un requisito di Perl6. (Deve avere un <precedente tutto >s.) Sono stato in grado di abbandonare quello <in linea in una posizione divisa dall'istinto e dalla preconoscenza risolvendo 05ab1e e il disaccordo di Perl6.

vortice

Le modifiche di Befunge sulla linea 2 hanno aggiunto un extra 1al poliglotta prima della linea Incidente / Vortice. Questo extra ha 1causato Whirl per iniziare indicando le istruzioni sbagliate sulla ruota. Il primo 1nella direttiva del preprocessore del C / C ++ era solo un riferimento al numero di riga nel codice, e questo poteva essere altrettanto facilmente qualsiasi altro numero di riga, quindi l'ho modificato arbitrariamente 4per soddisfare Whirl.

Incidente

La stringa di detokenizing alla fine del poliglotta è ben nota a questo punto, quindi non ci entrerò. Ho rimosso dalla stringa ciò che potevo e ho aggiunto i nuovi token richiesti. Ci sono 2 personaggi detokenizing che non sono in questa stringa, tuttavia, che dovrei sottolineare. Primo, secondoR in #R+.----.R >]|è necessario qui perché è un punto di fusione di partenza, ed era più sicuro su questa linea, perché c'era già una rubrica punto di fusione di partenza nella stessa direzione. In secondo luogo, xin #= xè di rimuovere un token coinvolto in un ␉␊#modello, che è diventato più comune.

Altri

Hexagony, Whitespace e Prelude avevano tutti i soliti piccoli aggiustamenti, ma niente di speciale da ricordare.

Pensieri finali

Questo è tutto ciò che ho per questa risposta. Per coloro che cercano un punto di partenza nella prossima risposta, suggerirei il male. Sembra fattibile, anche se non l'ho esaminato troppo da vicino, ma sospetto che non sarebbe troppo difficile integrarlo. So che ha un comando di salto che dovrebbe aiutare a saltare la maggior parte del poliglotta. In bocca al lupo.

183. Immagine di avvio Intel 8080 (ZEMU), 9870 byte

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

Provalo online!

Spiegazione

Grazie a Potato44 per l'idea di aggiungere il codice macchina, è stato molto divertente dare questa risposta.

Non ho fatto il file COM CP / M perché limita la dimensione del poliglotta a circa 60 KB che voglio evitare. L'immagine di avvio è risultata ancora più semplice da eseguire rispetto a COM perché ZEMU carica il settore di avvio dal 6 ° settore per impostazione predefinita (settori logici a 1 byte, 128 byte), quindi non è necessario eseguire l'avvio del poliglotta. Il codice di avvio deve trovarsi nell'offset 0x280 ((6-1) * 128) nel poliglotta.

Uso l' emulatore ZEMU che è collegato da questa pagina . Per eseguire polyglot in ZEMU:

• Dischi> A: seleziona il file poliglotta
• Opzioni> Set di istruzioni I8080
• Premi il pulsante Boot

La funzione che stampa un carattere su console ( cns$ot) è stata copiata da BIOS22Dv221.ASM dalla distribuzione ZEMU. Ho apportato due modifiche: il carattere non è mascherato in ASCII a 7 bit perché controlliamo i parametri e jrz cns$otviene sostituito con jz cns$otperché jrz(salto relativo se zero) è l'istruzione Zilog Z80 non presente in Intel 8080.

Programma iniziale ( sintassi Intel , assemblatore collegato da qui ):

    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

Questo programma contiene caratteri che non possono essere usati direttamente in poliglotta. La maggior parte dei caratteri di controllo ASCII (codice <0x20) sono vietati in Simula, i caratteri non ASCII (codice> = 0x80) non possono apparire da soli perché il file deve essere UTF-8 valido. Quindi il programma sopra è generato da un altro programma valido UTF-8.

Il seguente programma genera il codice necessario e passa ad esso. ld (hl),anon può essere utilizzato a causa di Grass ( 'w'==0x77). sub h(0x94) e xor a(0xAF) sono byte di continuazione UTF-8, devono essere anteposti con byte iniziale UTF-8. L'istruzione ret nc(= 0xD0, return if not carry) viene utilizzata come byte iniziale UTF-8. Per farlo non fare nulla è preceduto scfdall'istruzione (imposta flag carry). Evitato anche ','(0x2C) e '.'(0x2E) per DOBELA. org 0100hdirettiva non viene utilizzata perché l'assemblatore utilizzato non la comprende (l'organizzazione è impostata nella GUI). Questo programma è comunque indipendente dalla posizione. Mi piace di più Zilog mnemonics, quindi li ho usati per un programma più lungo.

Sintassi di Zilog , assemblatore collegato da qui :

  ; 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

Questo programma è assemblato in:

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

Deve trovarsi nell'offset 0x280 nel poliglotta (vedere la riga 2). Il test di astrazione nel driver di test lo verifica.

refactoring

conchiglie

Riportato i gusci sulla linea più lunga. Mi piace di più questo layout perché le parentesi non si allineano con altre lingue. Sposta Moorhenses e Flaks prima delle shell, quindi non si rompono quando le shell vengono cambiate. La linea più lunga ha ora questo layout:

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

Nuovo codice 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

Vecchio codice shell:

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 lunghezza di $aè calcolata $(echo -n $a | wc -c)ormai (da qui ). Inizialmente l'ho usato per sbarazzarmi di #, ma ora è usato a causa del codice più breve. Le conchiglie possono contenere #perché le scaglie sono prima delle conchiglie.

Yash (166) usa il comando echo incorporato che non supporta le opzioni di default, quindi "-n" e il linefeed finiscono per far parte dell'output, che dà 4 byte aggiuntivi. Quando non si imposta l' ECHO_STYLEimpostazione predefinita su SYSV(l' -nopzione non è accettata).

Questo collegamento TIO testa il codice in tutte le shell.

Ulteriori (((((prima delle shell risolvono Underload e Retina. Un'altra coppia di parentesi viene aggiunta per nascondere 58da Prelude (chiusa con #)after exit). {prima ((((((è per Japt, senza di esso Japt si blocca.

Flaks

A causa del trasferimento del codice di avvio Flaks può essere semplificato - ([])rimane solo :

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

Questo collegamento TIO testa il codice in tutti i Flaks.

Fissione e cardinale

La fissione è stato spostato in LNUSP: R"12"R _*. Il secondo puntatore viene utilizzato per terminare Fission il più presto possibile - al 3 ° passaggio, vedere la risposta 54 per ulteriori informazioni.

Il cardinale è stato spostato in LNUSP: @ %"18". Come in Fissione, il secondo puntatore viene utilizzato per terminare il Cardinale il più presto possibile - al 3 ° passaggio.

MarioLANG

Usa ####...invece che ====...come piattaforma:

Minimal-2D

Poliglotta con MarioLANG:

Wierd & 1L_a

Strano: usa lo spazio alla riga 10 colonna 79 per riflettere IP.
1L_a, Wierd: lo spazio alla riga 9 colonna 79 è importante.

cubica

Nuovo codice: :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

Nuovo codice: !|*****[[[828+*+@+*99]]]*****|!

Dopotutto la pila di moltiplicazioni contiene un singolo zero perché lo scoppio dalla pila vuota dà zero. Questo zero viene aggiunto al numero principale con +accanto a @. In precedenza era stato scartato ?, vedi risposta Klein 001 .

Come funzionano le porte in Klein:

vortice

Il codice Whirl è sostanzialmente lo stesso, l'unica modifica è che il codice principale presuppone che l'operazione corrente sia ops.one (2), non ops.load (4).

In effetti, si può pensare che Whirl abbia 3 operazioni:

• 1 ruotare di un passo
• 0 cambiare il senso di rotazione
• 00 eseguire le istruzioni correnti e cambiare anello

Operazioni combinate per semplificare il ragionamento sul programma:

• 0000 se l'operazione corrente dell'anello inattivo è noop, allora esegui solo l'operazione corrente dell'anello attivo senza effetti collaterali
• 11..11 ruota di n passi
• 011..11 cambia direzione e ruota di n passi

0000esegue l'istruzione corrente dell'anello attivo, ma esegue anche l'istruzione corrente dell'anello inattivo come effetto collaterale. Se l'attuale istruzione di suoneria inattiva è innocua, allora possiamo semplicemente concentrarci sulle operazioni su suoneria attiva senza pensare a ciò che sta accadendo con suoneria inattiva. Ciò è particolarmente utile con questo programma perché ha una chiara separazione: prima il numero 32 viene creato usando solo l'anello di matematica e poi passiamo all'ops ring ed eseguiamo 2 istruzioni lì (stampa ed esci).

Per prima cosa, volevo che l'operazione corrente sull'anello operativo fosse noop quando inizia l'esecuzione del codice principale. Presenta 2 vantaggi: 1) il codice Whirl principale può essere eseguito autonomamente e 2) possiamo completamente dimenticare l'operazione ops ring quando si crea il numero 32 con l'anello matematico. Tuttavia, rende il codice più lungo di quanto non fosse, quindi invece il codice principale presuppone che l'operazione corrente sia ops.one (2). Significa che ops.value è impostato su 1 come effetto collaterale delle operazioni matematiche, che viene quindi utilizzato per la stampa. Il vecchio codice ha ottenuto lo stesso effetto con l'istruzione ops.load, ma l'utilizzo di ops.one esprime più chiaramente l'intenzione - di impostare ops.value su un valore diverso da zero.

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

Il nuovo codice è più breve perché il vecchio codice ha un paio di interruttori di direzione ridondanti nella seconda parte del programma, non a causa di nuovi presupposti.

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

Come mantenere Whirl corretto quando si cambia qualcosa prima della linea Incident / Whirl:

• assicurarsi che ci sia un numero pari di 0s prima del codice Whirl principale
• accertarsi che non siano due consecutivi 0s
• aggiungere / rimuovere abbastanza 1s fino a quando Whirl funziona di nuovo; aggiungere n 1s equivale a rimuovere 12-n se 1viceversa

Ho inconsapevolmente infranto la prima regola quando ho aggiunto Ropy. Quando c'è un numero dispari di 0codice principale s inizia l'esecuzione con una direzione errata dell'anello operativo che interrompe le istruzioni di uscita. Quindi ora c'è 0sulla linea 3 che compensa 0sulla linea 1.

Altri

CoffeeScript : console.log a&&39||180(da qui )

INTERCAL : spostato sulla linea 37
Brainfuck , Agony : spostato su altri derivati ​​del brainfuck sulla linea 10

xEec : spostato in 1L_a ( h#115# o#)

CSL : spostato sulla linea 80
Trefunge : spostato sulla linea 120
Gaot ++ , Pietre : posizionate su linee separate

16. Pyth (159 byte)

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

Nota: esiste un ESCbyte ( 0x1B) dopo la onella terza riga e dopo jla nell'ultima riga.

Questa è stata un'esperienza abbastanza divertente. Japt e Pyth sono entrambi linguaggi da golf, ma Japt è infisso e Pyth è prefisso, e Pyth richiede l'immissione automatica e fallisce se mancano gli argomenti.

Prima della risposta Haystack avevo una soluzione quasi funzionante # un codice char in Japt e un errore loop-until in Pyth. Pyth sembra essere molto utile nei poliglotti, poiché il carattere di commento comune #funziona essenzialmente come silenziatore di errori.

Quando sono tornato a casa sono riuscito a trovare un pezzo di codice che funzionava con entrambi // , che funziona come un commento in Japt e due divisioni in Pyth. Quindi si trattava solo di far instradare correttamente i Befunges.

È molto improbabile che sia ottimale, ma per ora è abbastanza buono. Ho provato a testarli tutti, ma apprezzerei molto qualcuno che ricontrolla che gli output corrispondano.

Stampe 1 in Python 3 , 2 in V , 3 in Minkolang , 4 a> <> , 5 in Python 2 , 6 in automodificante Brainfuck , 7 in Japt , 8 in Retina , 9 in Perl , 10 in Befunge (-93 ) , 11 in Befunge-98 , 12 in Fission , 13 in Ruby , 14 in Turtléd , 15 in Haystack e

16 in Pyth .

Spiegazione

Ciò che Pyth vede qui è:

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

Questo si traduce nel seguente pseudocodice:

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"

Il primo ciclo termina quando si tenta di valutare ;quale non è un'espressione valida. Quindi Pyth stampa 16.