Quindi ... e 'un po' imbarazzante. Ma non abbiamo un semplice "Ciao, mondo!" sfida ancora (nonostante abbia 35 varianti taggate con hello-world e contando). Anche se questo non è il codice golf più interessante nelle lingue comuni, trovare la soluzione più breve in alcuni esolang può essere una sfida seria. Ad esempio, per quanto ne sappia non è noto se sia stata ancora trovata la soluzione Brainfuck più breve possibile.

Inoltre, mentre tutta Wikipedia (la voce di Wikipedia è stata cancellata ma ce n'è una copia su archive.org ), esolangs e Rosetta Code hanno elenchi di "Hello, World!" programmi, nessuno di questi è interessato ad avere il più breve per ogni lingua (esiste anche questo repository GitHub ). Se vogliamo essere un sito significativo nella community del code golf, penso che dovremmo provare a creare il catalogo definitivo del più breve "Hello, World!" programmi (simile al modo in cui la nostra sfida di base dei quine contiene alcuni dei più brevi quines conosciuti in varie lingue). Quindi facciamolo!

Le regole

• Ogni invio deve essere un programma completo.
• Il programma non deve ricevere input e stampare Hello, World!su STDOUT (questo esatto flusso di byte, inclusi maiuscole e punteggiatura) più una nuova riga finale opzionale e nient'altro.
• Il programma non deve scrivere nulla su STDERR.

• Se qualcuno vuole abusare di questo creando una lingua in cui il programma vuoto viene stampato Hello, World!, quindi congratulazioni, hanno appena aperto la strada a una risposta molto noiosa.

  Si noti che deve essere presente un interprete per poter testare l'invio. È permesso (e persino incoraggiato) di scrivere questo interprete per una lingua precedentemente non implementata.

• Le iscrizioni vengono classificate in byte , con una codifica appropriata (preesistente), di solito (ma non necessariamente) UTF-8. Alcune lingue, come Cartelle , sono un po 'difficili da segnare - in caso di dubbi, si prega di chiedere su Meta .
• Non si tratta di trovare la lingua con il più breve "Ciao, mondo!" programma. Si tratta di trovare il più breve "Ciao, mondo!" programma in ogni lingua. Pertanto, non contrassegnerò alcuna risposta come "accettata".
• Se la tua lingua preferita è una variante banale di un'altra lingua (potenzialmente più popolare) che ha già una risposta (pensa a dialetti BASIC o SQL, shell Unix o banali derivati ​​Brainfuck come Alphuck), considera di aggiungere una nota alla risposta esistente che il la stessa o una soluzione molto simile è anche la più breve nell'altra lingua.

Come nota a margine , ti preghiamo di non sottovalutare le risposte noiose (ma valide) in lingue in cui non c'è molto da golf - queste sono ancora utili a questa domanda in quanto cerca di compilare un catalogo il più completo possibile. Tuttavia, fare le risposte soprattutto Upvote nelle lingue in cui gli autori in realtà ha dovuto impegnarsi nel golf il codice.

Per ispirazione, controlla la collezione Hello World .

Il catalogo

Lo snippet di stack nella parte inferiore di questo post genera il catalogo dalle risposte a) come elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

## Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

## [><>](https://esolangs.org/wiki/Fish), 121 bytes

/* Configuration */

var QUESTION_ID = 55422; // Obtain this from the url
// It will be like https://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 "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://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 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,
      });
    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};
  });

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

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 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.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body {
  text-align: left !important;
  display: block !important;
}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 500px;
  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="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<div id="language-list">
  <h2>Shortest Solution by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

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

Bloccato, 0 byte

Beh, non posso essere più breve di così ... Verrà emesso un programma vuoto Hello, World!in Stuck .

PHP, 13 byte

Hello, World!

Sì. Funziona.

Brainfuck, 78 byte

Taglia illimitata : se qualcuno può migliorare questo punteggio, gli passerò la taglia (+500). @KSabha trovato unasoluzione a 76 72 byte!

--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.

Provalo online!

I primi 28 byte --<-<<+[+[<+>--->->->-<<<]>]inizializzano il nastro con la seguente relazione di ricorrenza (mod 256):

f _n = 171 · (-f _n-1 - f _n-2 - f _n-3 + 1) , con f ₀ = 57 , f ₁ = 123 e f ₂ = 167 .

Il fattore di 171 sorge perché 3 ^-1 ≡ 171 (mod 256) . Quando il valore corrente viene convertito indietro di una cella (via <+>---) sottraendo 3 ogni volta moltiplica effettivamente il valore per 171.

A n = 220 il valore da tradurre è zero e l'iterazione si interrompe. I dieci byte che precedono il punto di arresto sono i seguenti:

[130, 7, 43, 111, 32, 109, 87, 95, 74, 0]

Questo contiene tutti i componenti necessari per produrre Hello, World!, in modo caccia e beccare, con piccoli aggiustamenti.

Ho anche trovato una soluzione alternativa a 78 byte:

-[++[<++>->+++>+++<<]---->+]<<<<.<<<<-.<..<<+.<<<<.>>.>>>-.<.+++.>>.>-.<<<<<+.

Provalo online!

Considero questo uno migliore del primo per diversi motivi: utilizza meno celle rimaste a casa, modifica meno celle in totale e termina più rapidamente.

Più dettaglio

Le relazioni di ricorrenza hanno rappresentazioni sorprendentemente concise in Brainfuck. Il layout generale è il seguente:

{...s3}<{s2}<{s1}[[<+>->{c1}>{c2}>{c3...}<<<]>{k}]

che rappresenta:

f _n = c ₁ · f _n-1 + c ₂ · f _n-2 + c ₃ · f _n-3 + ... + k

con

f ₀ = s ₁ , f ₁ = s ₂ + c ₁ · f ₀ + k , f ₂ = s ₃ + c ₂ · f ₀ + c ₁ · f ₁ + k , ecc.

Inoltre, <+>può essere modificato per moltiplicare l'intervallo per una costante senza influire sul punto di arresto e un termine può essere aggiunto prima >{k}di spostare l'intervallo per una costante, di nuovo senza influire sul punto di arresto.

Altri esempi

Sequenza di Fibonacci

+[[<+>->+>+<<]>]

Numeri N-gonali

Numeri triangolari

+[[<+>->++>-<<]>+]

Definito come f _n = 2 · f _n-1 - f _n-2 + 1 , con f ₀ = 0 , f ₁ = 1 .

Numeri quadrati

+[[<+>->++>-<<]>++]

Numeri pentagonali

+[[<+>->++>-<<]>+++]

eccetera.

BF Crunch

Ho pubblicato il codice che ho usato per trovare alcune di queste soluzioni su github . Richiede .NET 4.0 o versioni successive.

Usage: bfcrunch [--options] text [limit]

Arguments
------------------------------------------------------------
  text              The text to produce.
  limit             The maximum BF program length to search for. If zero, the length of the
                    shortest program found so far will be used (-r). Default = 0

Options
------------------------------------------------------------
  -i, --max-init=#  The maximum length of the initialization segment. If excluded, the
                    program will run indefinitely.
  -I, --min-init=#  The minimum length of the initialization segment. Default = 14
  -t, --max-tape=#  The maximum tape size to consider. Programs that utilize more tape than
                    this will be ignored. Default = 1250
  -T, --min-tape=#  The minimum tape size to consider. Programs that utilize less tape than
                    this will be ignored. Default = 1
  -r, --rolling-limit
                    If set, the limit will be adjusted whenever a shorter program is found.
  -?, --help        Display this help text.

L'output è dato in tre righe:

1. Lunghezza totale del programma trovato e segmento di inizializzazione.
2. Percorso eseguito, a partire dal puntatore del nastro corrente. Ogni nodo corrisponde a un carattere di output, rappresentato come (puntatore, costo).
3. Segmento nastro utilizzato.

Ad esempio, il risultato finale per bfcrunch "hello world" 70 -r -i23è:

64: ++++[[<+>->+++++>+<<]>]
49, (45, 5), (44, 3), (45, 6), (45, 1), (45, 4), (42, 4), (43, 5), (45, 3), (45, 4), (46, 2), (44, 4)
32, 116, 100, 104, 108, 132, 0, 0, 132, 0

Questo corrisponde al programma completo:

++++[[<+>->+++++>+<<]>]<<<<.<+.>++++..+++.<<<.>+++.>>.+++.>.<<-.

Altri record

Ciao mondo!

involucro, 78 byte :

--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.

o

-[++[<++>->+++>+++<<]---->+]<<<<.<<<<-.<..<<+.<<<<.>>.>>>-.<.+++.>>.>-.<<<<<+.

Non a capo, 87 byte (precedentemente 92 byte (mitchs) ):

--->->->>+>+>>+[++++[>+++[>++++>-->+++<<<-]<-]<+++]>>>.>-->-.>..+>++++>+++.+>-->[>-.<<]

Ciao mondo!

A capo, 80 byte :

++<-[[<+>->+>--->-<<<]>+++]>+.<<<<<<<++.>>>..>.<<--.<<<--.>>+.>>>.+++.<.<<<-.<+.

Non-wrapping, 81 byte (precedentemente 92 byte (hirose) ):

+>---->->+++>++>->+[++++++++[>++++++++>>+++++<<<-]<]>>.>++>.>..+>>.+>-->--[>-.<<]

Ciao mondo!

A capo, 74 byte :

-<++[[<+>->->+++>+<<<]->]<<.---.<..<<.<<<---.<<<<-.>>-.>>>>>.+++.>>.>-.<<.

Non a capo, 84 byte :

---->+++>++>->->++[+++++++[>+++++[>++>>+<<<-]<-]++<]>>>>.---.>---..+>->.+>-->+>[-.<]

EsolangsVersione

Ciao mondo! \ N

A capo, 76 byte :

+[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.[<]>+.

Questo utilizza una cella lasciata di casa e quindi sarebbe considerata 77.

Non a capo, 83 byte :

->+>>>+>>---[++++++++++[>++++++>+++>+<<<-]-<+]>+>+.>.->--..>->-.>[>.<<]>[+>]<<.>++.

Approvato Rdebath . output di profilebf:

Hello World!
Program size 83
Final tape contents:
 :   0   0  73 101 109 115 112  88  33  10   0
                                         ^
Tape pointer maximum 10
Hard wrapping would occur for unsigned cells.
Counts:     +: 720          -: 79           >: 221          <: 212
Counts:     [: 9            ]: 84           .: 13           ,: 0
Total:         1338

inversed.ru (Peter Karpov)

Ciao mondo!

A capo, 70 byte (precedentemente 78 ¹ ):

+[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.

Non a capo, 77 byte (precedentemente 89?):

->+>>>+>>-[++++++[>+++++++++>+++++>+<<<-]<+]>>.>--.->++..>>+.>-[>.<<]>[>]<<+.

L'autore afferma che il più breve scritto a mano "Hello World!" è di 89 byte, ma non fornisce alcun riferimento. Con la presente rivendico anche questo record.

Ciao mondo!

A capo, 65 byte (precedentemente 66 byte):

+++[>--[>]----[----<]>---]>>.---.->..>++>-----.<<<<--.+>>>>>-[.<]

Anche questo è in realtà codificato a mano (il migliore che ho trovato con lo scricchiolio è di 68 byte ). La prima cella viene inizializzata a 259 (3) e decrementata di 7 ogni iterazione, eseguendo un ciclo di 37 volte. La cella successiva viene decrementata di 6, risultando in 256 - 6 · 37 = 34 . Il resto delle celle viene decrementato di 4 ogni volta, aggiungendo una cella ogni iterazione, con ogni nuova cella inializzata a 252 (-4). Il risultato è il seguente:

[  3,   0,   0,   0,   0,   0,   0, ...]
[252, 250, 248,   0,   0,   0,   0, ...]
[245, 244, 244, 248,   0,   0,   0, ...]
[238, 238, 240, 244, 248,   0,   0, ...]
[231, 232, 236, 240, 244, 248,   0, ...]
[224, 226, 232, 236, 240, 244, 248, ...]
...
[ 35,  64, 124, 128, 132, 136, 140, ...]
[ 28,  58, 120, 124, 128, 132, 136, ...]
[ 21,  52, 116, 120, 124, 128, 132, ...]
[ 14,  46, 112, 116, 120, 124, 128, ...]
[  7,  40, 108, 112, 116, 120, 124, ...]
[  0,  34, 104, 108, 112, 116, 120, ...]

¹ La soluzione fornita (79 byte) può essere banalmente ridotta di uno:

-[>>+>+[++>-<<]-<+<+]>---.<<<<++.<<----..+++.>------.<<++.>.+++.------.>>-.<+.

ArnoldC , 71 byte

IT'S SHOWTIME TALK TO THE HAND "Hello, World!" YOU HAVE BEEN TERMINATED

Solo per lols ..

Seme , 6016 4234 4203 byte

20 854872453003476740699221564322673731945828554947586276010721089172712854441839676581917455319274850944955030258951339804246125714958815519550291630078076933441706558540342671975808828643360922071900333028778314875248417953197990571991784126564752005357199892690656368640420204822142316716413192024742766282266114842280731756458212469988291309261528542889299297601723286769284159107438930448971911102280330101196758384815655479640836157495863547199726234352265518586460633795171196315255736880028338460236768181141732764911402112878175632130129852788301009582463631290071329795384336617491655825493435803011947670180368458659271192428341035912236946048939139042310380278430049252171822721598175984923434205610723412240162418996808671543770639111617709604242882388664919702606792443015941265168129550718541372361144081848761690730764968771245566074501485020726368378675085908872608679630368472956274468410052703615106090238423979678950131481176272880569100533049143775921798055136871254424261001442543122666701145111965968366507060931708140304772342855064834334129143038575569044150428480231956133612367393837580345180691911525531699573096952433882387811884727975431823620782822755161559988205401134640722220804177812794328129589949692446031008866917615922944976151073653201316255518389496411696741029209242119521978920200314572718584995265523235225587228975886710511855501710470163649632761488899317729943053884132314641377747687975638119132094777769497069556255954031537245957811105217875011509899497752696062748928963281605780942517262774976217663461063680912331030221981433051827519906741285738915397005702326447635845195923640649166530310494885569783989508000344280715868581532826832242144647203531393142251025361866506821695860883605004105862208004440476654027574832078603305884731766236740069411566854496824754558761536201352147934963241039597221404341132342297870517293237489233057335406510464277610336142382379135365550299895416613763920950687921780736585299310706573253951966294045814905727514141733220565108490291792987304210662448111170752411153136765318541264632854767660676223663544921028492602135525959428999005153729028491208277493747933069008199074925710651071766675870081314909460661981433426167330215548196538791617762566403934129026219366764038390123622134753742930729751695349588862441999672547791630729398908283091638866715502470152431589429837867944760012419885615525232399584379209285060418518373512154801760060312646951597932345591416241634668119867158079946680321131213357200382937049485606706114467095019612014749723443159443363662563254359712162432143334612180576945072905749883870150120687696027984317320305291407322779803583395375616762530641605634303022155218169343410634115050596030685041633824154135240376022159918501703555881290333205131375705406831260759974112248490451605422031345264183102048614606636275942039438138959188478277971377232005036301145411215067576576667743288951344423152531417111852584846747428443123174595987315325304540564683047858415059703724263652136185848573853965992798725654430360647040362341567082462847275277303225817689141675391972818943419663764371222973269129542760661385278009266471167618553065823580448848795731295589715602705860758954890415040763604082216728159486423396295188510311881004469017351709060492844398219491990895826924575575549615118821417543037296628825303328056839433114519945243963946989899508355224823109677424196639930153649890175062456649384605721510239142861693109687536600667811037619175927995599388547421689316110236566026931360164495251160997857372500940728057700473763884480342708897319990346726967220426504612260565552531158509215849649565188655100774748485416791517853427613458459889062942881409801879085054494129489535044719193283409051007851153504224002807392992520076910314763705776345053922387355156981872691537772657428096384535960466923475731297217863371650154415835785630016335858514130863258775100537612371430357576913148500310344278511588325852376442503898849856566716198848377379400158332792027967216204970114516984638014129252882482309132898416484525230488700253065644547798869056136044415413099076332059572505138116227535024546891015836838323022822272664771489129085797354578016574544759934333471793

Il risultante programma Befunge-98 (basato su questo ) è

"9!dlroW ,olleH"ck,@

Mornington Crescent , 3614 3568 byte

Grazie a NieDzejkob per aver salvato 46 byte usando nomi di linea più brevi.

Take Northern Line to Hendon Central
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Gunnersbury
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Paddington
Take District Line to Acton Town
Take Piccadilly Line to Holloway Road
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Mile End
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Mile End
Take District Line to Paddington
Take Circle Line to Paddington
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminals 1, 2, 3
Take Piccadilly Line to Holborn
Take Central Line to Holborn
Take Central Line to Mile End
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Barking
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Barking
Take District Line to Gunnersbury
Take District Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Wood Lane
Take Circle Line to Victoria
Take Circle Line to Victoria
Take District Line to Gunnersbury
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Gunnersbury
Take District Line to Paddington
Take Circle Line to Paddington
Take District Line to Mile End
Take Central Line to Fairlop
Take Central Line to Mile End
Take District Line to Barking
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Mile End
Take District Line to Gunnersbury
Take District Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take District Line to Mile End
Take District Line to Richmond
Take District Line to Mile End
Take District Line to Paddington
Take Circle Line to Paddington
Take District Line to Richmond
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Stepney Green
Take District Line to Hammersmith
Take District Line to Stepney Green
Take District Line to Upney
Take District Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Upney
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Bakerloo Line to Charing Cross
Take Bakerloo Line to Paddington
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

Provalo online!

Questo è sicuramente non ottimale, ma è la metà della dimensione della soluzione su esolangs.

Hello, World viene costruito tagliando i seguenti nomi di stazioni e concatenando i risultati:

Hendon Central
▀▀
Holloway Road
  ▀▀▀
Heathrow Terminals 1, 2, 3
                       ▀▀
Wood Lane
▀▀
Fairlop
   ▀▀
Richmond
       ▀

Infine, sto calcolando il codice carattere di !come (2<<4)+1 == 33. Tutte queste parti sono concatenate a Paddington e infine stampate a Mornington Crescent.

Nota: la lingua non specifica se è possibile viaggiare sulla stessa stazione due volte di seguito, ma l'interprete lo consente, quindi l'ho usato.

male , 70 byte

aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

Utilizza i seguenti quattro comandi:

a - increment the register
u - decrement the register
e - interweave the register's bits (01234567 -> 20416375)
w - write the value of the register as an ASCII character

Brainfuck, 72 byte

+[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.

Provalo online!

E la soluzione originale a 76 byte non avvolgente :

+[+[<<<+>>>>]+<-<-<<<+<++]<<.<++.<++..+++.<<++.<---.>>.>.+++.------.>-.>>--.

Provalo online!

Altre soluzioni più note (per quanto ne so) che ho trovato

'Ciao mondo!' 77 byte:

+[+++<+<<->>>[+>]>+<<++]>>>>--.>.>>>..+++.>>++.<<<.>>--.<.+++.------.<<<-.<<.

Provalo online!

'Ciao mondo!' 70 byte:

+[>>>->-[>->----<<<]>>]>.---.>+..+++.>>.<.>>---.<<<.+++.------.<-.>>+.

Provalo online!

Questi sono stati trovati usando un programma c ++ che ho scritto qui: https://github.com/ksabry/bfbrute

Nota: originariamente volevo ripulire questo codice prima di pubblicarlo per renderlo in qualche modo leggibile e utilizzabile, ma dal momento che non ci arrivo da oltre un anno immagino che lo posterò così com'è. Fa un uso pesante di modelli e compilazioni di costanti di tempo per eventuali ottimizzazioni e ha un sacco di codice commentato dai miei test, ma nessun commento utile così dispiaciuto ma è un po 'orribile.

Non c'è nulla di terribilmente intelligente nel codice, è il forcer brutale al suo interno, tuttavia è abbastanza ottimizzato. La principale ottimizzazione è che prima scorre attraverso tutti i programmi senza loop (no [o ]) fino a una lunghezza specificata (16 attualmente) e memorizza nella cache una matrice di tutte le modifiche che farà sulla matrice di dati. Memorizzerà solo un singolo programma per array univoco di modifiche, ad esempio solo uno >+<<->e <->>+<verrà memorizzato. Quindi scorre attraverso tutti i possibili programmi che sono composti da qualsiasi programma in questa cache con qualsiasi combinazione di loop tra di loro. Dopo aver eseguito ciascun programma, esegue una semplice caccia avida e becca i personaggi e lo aggiunge alla fine del programma.

Dopo averlo eseguito nello spazio di tutti i programmi, ho notato che quasi tutti i programmi più brevi (fino a una lunghezza di ~ 19) erano di forma *[*[*]*]. Limitare la ricerca ai programmi di questo modulo ha accelerato notevolmente la ricerca. L'attuale detentore del record è stato trovato alla lunghezza 27. Questo è stato effettivamente calcolato per essere la lunghezza 74, ma ho notato una sequenza particolare .>.>.>.che è stata abbastanza fortunata da avere uno 0 nella cella di dati a destra, permettendogli di essere semplificato per [.>]<abbatterlo a 72.

L'ho lasciato funzionare per un po 'e ho completato la ricerca con i parametri attuali fino alla lunghezza 29, sospetto che sarà difficile battere quello attuale semplicemente andando più in alto, penso che l'approccio più promettente sarebbe probabilmente aumentare lo spazio di ricerca in in qualche modo intelligente.

Piet, 90 codici

Questa è un'immagine 30 per 3. In alternativa, alla dimensione del codice 10:

Usa un layout a 3 alte, quindi devo puntare solo una volta. Se questo è ancora golfabile, potrei probabilmente radermi al massimo in un'altra colonna, dal momento che c'è un push-pop no-op.

Modifica: la soluzione di codel di @ primo's 84 .

Pagliaio , 17 byte

Haystack è un linguaggio di programmazione 2D che viene eseguito fino a quando non trova l'ago nel pagliaio | , il tutto mentre esegue operazioni basate su stack. Tutti i programmi iniziano dall'angolo in alto a sinistra e possono usare i caratteri direzionali ><^vper spostarsi all'interno del programma. La direzione viene ereditata, quindi non è necessario continuare a utilizzarla> per andare a destra, la direzione cambierà solo quando colpisce un diverso carattere direzionale.

Per impostazione predefinita, l'interprete legge dall'alto a sinistra andando a destra, quindi possiamo semplicemente mettere "Ciao, mondo!" sullo stack, utilizzareo per stamparlo, quindi posizionare l'ago per terminare l'esecuzione.

"Hello, World!"o|

Bonus: una versione più eccitante:

v      >;+o|
v      "
v      !
v      d
v      l
v      r
>>"Hello, ">>>v
       W      v
       "      v
       ^<<<<<<<

Aiuto, WarDoq! , 1 byte

H

Non solo aiuta, WarDoq! hanno un built-in per l'ortografia più comune della frase, soddisfa anche la nostra solita definizione di linguaggio di programmazione.

Provalo nell'interprete online ufficiale (il codice va in Input ).

MarioLANG , 259 249 242 240 235 byte

+>+>)+)+)+++)++++((((-[!)>->.
+"+"===================#+".")
+++!((+++++++++)++++++)<.---+
++=#===================")---.
++((.-(.)).+++..+++++++.<---
 !+======================---
=#>++++++++++++++.).+++.-!>!
  =======================#=#

Questo è stato testato nell'implementazione di Ruby .

Dopo aver offuscato "Ciao, mondo!"in MarioLANG ho cercato un po 'di golf. Quanto sopra è il più breve che ho trovato finora.

Come prima ho iniziato con una soluzione Brainfuck che imposta quattro celle al multiplo più vicino di 10 per i caratteri He,e lo spazio e lo converte in MarioLANG . È quindi possibile abbreviare un po 'il codice facendo uso del piano ausiliario nel loop che quasi dimezza la larghezza del loop. Si noti che il fondo viene eseguito solo una volta in meno del primo, quindi non si ottengono più multipli esatti del contatore iniziale in tutte e 4 le celle.

Alla fine, volevo sfruttare lo spazio sprecato di fronte al circuito, quindi ho aggiunto un gruppo di ascensori per sfruttare lo spazio verticale lì. E poi mi sono reso conto che avrei potuto piegare il codice dopo il loop (vedi la revisione precedente) sotto il loop per sfruttare un po 'più di spazio verticale, risparmiando altri cinque byte.

Questo è probabilmente tutt'altro che perfetto, ma penso che sia un miglioramento decente rispetto alla soluzione ingenua.

Metagolf

Tempo per un po 'di automazione ...

Ho iniziato a installare un risolutore in Mathematica per trovare una soluzione ottimale. Si presuppone attualmente che la struttura del codice sia fissa: contatore impostato su 12, 4 celle per la stampa, con l'assegnazione fissa a He,<space>e lo stesso ordine di quelle celle. Ciò che varia è il numero di +s nel loop e le necessarie correzioni successive:

n = 12;
Minimize[
 {
  3(*lines*)+
   12(*initialiser base*)+
   Ceiling[(n - 6)/2] 3(*additional initialiser*)+
   8(*loop ends*)+
   18(*cell moves*)+
   26(*printing*)+
   43*2(*steps between letters in one cell*)+
   -2(*edge golf*)+
   4 Max[4 + a + d + g + j + 2 Sign[Sign@g + Sign@j] + 2 Sign@j + 2,
     4 + b + e + h + k + 2 Sign[Sign@h + Sign@k] + 2 Sign@k] +
   2 (Abs@c + Abs@f + Abs@i + Abs@l),
  a >= 0 && d >= 0 && g >= 0 && j >= 0 &&
   b >= 0 && e >= 0 && h >= 0 && k >= 0 &&
   n*a + (n - 1) b + c == 72 &&
   n*d + (n - 1) e + f == 101 &&
   n*g + (n - 1) h + i == 44 &&
   n*j + (n - 1) k + l == 32
  },
 {a, b, c, d, e, f, g, h, i, j, k, l},
 Integers
 ]

Si scopre che per un contatore iniziale di 12 la mia soluzione artigianale è già ottimale. Tuttavia, l'utilizzo di 11 salva invece due byte. Ho provato tutti i valori dei contatori da 6 a 20 (inclusi) con i seguenti risultati:

6: {277,{a->7,b->6,c->0,d->16,e->1,f->0,g->0,h->9,i->-1,j->0,k->6,l->2}}
7: {266,{a->6,b->5,c->0,d->11,e->4,f->0,g->2,h->5,i->0,j->0,k->5,l->2}}
8: {258,{a->2,b->8,c->0,d->3,e->11,f->0,g->5,h->0,i->4,j->4,k->0,l->0}}
9: {253,{a->8,b->0,c->0,d->5,e->7,f->0,g->2,h->3,i->2,j->0,k->4,l->0}}
10: {251,{a->0,b->8,c->0,d->3,e->8,f->-1,g->4,h->0,i->4,j->3,k->0,l->2}}
11: {240,{a->1,b->6,c->1,d->1,e->9,f->0,g->4,h->0,i->0,j->3,k->0,l->-1}}
12: {242,{a->6,b->0,c->0,d->6,e->3,f->-4,g->0,h->4,i->0,j->0,k->3,l->-1}}
13: {257,{a->1,b->5,c->-1,d->6,e->2,f->-1,g->3,h->0,i->5,j->0,k->3,l->-4}}
14: {257,{a->1,b->4,c->6,d->0,e->8,f->-3,g->3,h->0,i->2,j->2,k->0,l->4}}
15: {242,{a->1,b->4,c->1,d->3,e->4,f->0,g->1,h->2,i->1,j->2,k->0,l->2}}
16: {252,{a->0,b->5,c->-3,d->4,e->2,f->7,g->0,h->3,i->-1,j->2,k->0,l->0}}
17: {245,{a->4,b->0,c->4,d->5,e->1,f->0,g->0,h->3,i->-4,j->0,k->2,l->0}}
18: {253,{a->4,b->0,c->0,d->1,e->5,f->-2,g->2,h->0,i->8,j->0,k->2,l->-2}}
19: {264,{a->0,b->4,c->0,d->5,e->0,f->6,g->2,h->0,i->6,j->0,k->2,l->-4}}
20: {262,{a->0,b->4,c->-4,d->5,e->0,f->1,g->2,h->0,i->4,j->0,k->2,l->-6}}

Nota: questo risolutore presuppone che il codice lineare dopo il ciclo sia tutto sulla riga superiore e che il codice sopra sia la soluzione ripiegata. Potrebbe esserci una soluzione globale più breve rendendo il risolutore consapevole della piegatura, perché ora ottengo 3 +s in più nella prima parte gratuitamente e le successive 4 istruzioni costerebbero solo 1 byte anziché 2.

Scuro , 106 byte

+h hell
h$twist sign s
s$scrawl " Hello, World!
s$read
h$twist stalker o
o$stalk
o$personal
o$echo
h$empty

Lascerò solo alcune citazioni dalla specifica del linguaggio parlare per lo splendore di questo esolang:

Dark è un linguaggio basato sulla manipolazione di interi mondi e dimensioni per raggiungere obiettivi e costruire la migliore realtà tortuosa possibile.

Ogni volta che si verifica un errore di sintassi, la sanità mentale del programma diminuisce di 1. [...] Se la sanità mentale del programma raggiunge lo zero, l'interprete diventa pazzo.

La corruzione lancia un singolo bit nella variabile quando si verifica.

Quando il master muore, muoiono anche tutte le variabili servant associate a quel master. Ciò è utile per raggruppare e uccidere in massa le variabili.

Forza una variabile a uccidersi, liberandola (ricorda però che lascerà il decadimento).

Imposta una variabile su un valore casuale. Utilizza il Global Chaos Generator.

Se uno stalker non viene inizializzato, qualsiasi tentativo di eseguire IO comporterà la scrittura di messaggi di errore deprimenti sulla console.

Homespring , 58 byte

Universe net hatchery Hello,. World!  powers a b snowmelt 

Lo spazio finale è significativo.

Lascia che ti racconti una storia. C'era una volta una centrale elettrica che alimentava un vivaio di salmoni nelle vicinanze. L'allevamento di salmoni ha dato alla luce un giovane salmone senza tetto che ha intrapreso un viaggio verso l'alto per trovare una sorgente. Ha trovato una tale sorgente, con il nome poetico "Hello, World!", Dove è maturato e ha generato un nuovo giovane salmone. Entrambi i pesci ora nuotavano a valle, alla ricerca del vasto oceano. Ma a poca distanza dalla foce del fiume, c'era una rete nel fiume - il pesce maturo fu catturato e solo il giovane riuscì a scivolare attraverso e raggiunse l'oceano e il resto dell'universo. Nel frattempo, il vivaio aveva covato più salmoni che avevano viaggiato anche a monte e si erano generati e così via e così via.

Tuttavia, enormi quantità di neve che si scioglieva avevano viaggiato lungo un diverso braccio del fiume. E subito dopo il nostro primo giovane salmone dalle sorgenti di "Hello, World!" ha raggiunto l'oceano, la fusione di neve ha colpito l'universo e ... l'ha ... distrutto. E vissero felici e contenti ... o immagino di no.

Quelle erano in realtà la semantica del programma di cui sopra. La primavera è strana.

Chef , 465 byte

H.

Ingredients.
72 l h
101 l e
108 l l
111 l o
44 l C
32 l S
87 l w
114 l r
100 l d
33 l X

Method.
Put X into mixing bowl.Put d into mixing bowl.Put l into mixing bowl.Put r into mixing bowl.Put o into mixing bowl.Put w into mixing bowl.Put S into mixing bowl.Put C into mixing bowl.Put o into mixing bowl.Put l into mixing bowl.Put l into mixing bowl.Put e into mixing bowl.Put h into mixing bowl.Pour contents of the mixing bowl into the baking dish.

Serves 1.

Testato con l'interprete Ruby. Fa la zuppa di alfabeto.

Ho cercato di essere il più conforme possibile alle specifiche originali , quindi anche se l'interprete che ho usato ti lascia cadere thele Pour contentsistruzioni, non l'ho fatto.

Il boccale è piuttosto costoso, quindi potrebbe esserci un approccio migliore. Ho provato a utilizzare la conversione di base per codificare il messaggio, ma sfortunatamente le specifiche non chiariscono se Divideutilizza la divisione in numeri interi o in virgola mobile e l'interprete che ho usato usa quest'ultimo. Non c'è nemmeno un operatore modulo, che non aiuta neanche.

Piet, 84 codici

28x3, qui mostrato con la larghezza del codice 10.

Creato con PietDev , testato con npiet . Il layout del programma è il seguente:

Il riempimento giallo indica i codici in cui il percorso si sovrappone, il riempimento arancione indica i codici che devono essere dello stesso colore, ai fini del flusso di controllo.

Per aiutare nella creazione di questo, ho scritto un interprete rudimentale per un linguaggio basato su stack con comandi simili a piet, che ho soprannominato "pasm" ( fonte ). L'output di questo interprete (con questo input ) è il seguente:

    1 nop     blu1 []
    4 push 3  blu2 [3]
    5 dup     grn2 [3, 3]
    6 add     cyn2 [6]
    7 dup     ylw2 [6, 6]
    8 mul     grn1 [36]
    9 dup     red1 [36, 36]
   10 dup     blu1 [36, 36, 36]
   11 add     mgn1 [36, 72]
H  12 putc    blu0 [36]
   15 push 3  blu1 [36, 3]
   16 sub     mgn2 [33]
   17 dup     cyn2 [33, 33]
   20 push 3  cyn0 [33, 33, 3]
   21 mul     blu2 [33, 99]
   22 push 1  blu0 [33, 99, 1]
   23 add     mgn0 [33, 100]
   24 dup     cyn0 [33, 100, 100]
   25 push 1  cyn1 [33, 100, 100, 1]
   26 add     blu1 [33, 100, 101]
e  27 putc    cyn0 [33, 100]
   28 dup     ylw0 [33, 100, 100]
   32 push 4  ylw1 [33, 100, 100, 4]
   33 dup     mgn1 [33, 100, 100, 4, 4]
   34 add     red1 [33, 100, 100, 8]
   35 add     ylw1 [33, 100, 108]
   36 dup     mgn1 [33, 100, 108, 108]
l  37 putc    blu0 [33, 100, 108]
   38 dup     grn0 [33, 100, 108, 108]
l  39 putc    ylw2 [33, 100, 108]
   40 dup     mgn2 [33, 100, 108, 108]
   43 push 3  mgn0 [33, 100, 108, 108, 3]
   44 add     red0 [33, 100, 108, 111]
   45 dup     blu0 [33, 100, 108, 111, 111]
o  46 putc    cyn2 [33, 100, 108, 111]
   47 dup     ylw2 [33, 100, 108, 111, 111]
   48 dup     mgn2 [33, 100, 108, 111, 111, 111]
   53 push 5  mgn0 [33, 100, 108, 111, 111, 111, 5]
   54 div     ylw0 [33, 100, 108, 111, 111, 22]
   55 dup     mgn0 [33, 100, 108, 111, 111, 22, 22]
   56 add     red0 [33, 100, 108, 111, 111, 44]
   57 dup     blu0 [33, 100, 108, 111, 111, 44, 44]
,  58 putc    cyn2 [33, 100, 108, 111, 111, 44]
   59 dup     ylw2 [33, 100, 108, 111, 111, 44, 44]
   60 add     grn2 [33, 100, 108, 111, 111, 88]
   64 push 4  grn0 [33, 100, 108, 111, 111, 88, 4]
   65 dup     red0 [33, 100, 108, 111, 111, 88, 4, 4]
   66 mul     ylw2 [33, 100, 108, 111, 111, 88, 16]
   67 dup     mgn2 [33, 100, 108, 111, 111, 88, 16, 16]
   68 add     red2 [33, 100, 108, 111, 111, 88, 32]
   69 putc    mgn1 [33, 100, 108, 111, 111, 88]
   70 push 1  mgn2 [33, 100, 108, 111, 111, 88, 1]
   71 sub     red0 [33, 100, 108, 111, 111, 87]
W  72 putc    mgn2 [33, 100, 108, 111, 111]
o  73 putc    blu1 [33, 100, 108, 111]
   76 push 3  blu2 [33, 100, 108, 111, 3]
   77 add     mgn2 [33, 100, 108, 114]
r  78 putc    blu1 [33, 100, 108]
l  79 putc    cyn0 [33, 100]
d  80 putc    grn2 [33]
!  81 putc    ylw1 []

Non vengono utilizzati comandi pointer, switch o roll. Neanche i codici vengono sprecati; infatti due vengono riutilizzati.

Spazio bianco , 192 150 146 byte

Lo spazio bianco ha bisogno solo di spazi, tabulazioni e avanzamenti di riga mentre gli altri personaggi vengono ignorati.
Che può essere problematico da visualizzare qui.
Quindi nel codice sottostante sono stati sostituiti gli spazi e le schede.
E un ';' è stato messo di fronte alle linee di alimentazione per chiarezza.
Per eseguire il codice, sostituire innanzitutto. e> per spazi e tabulazioni.

...;
..>>..>.>.;
..>>>>;
...>;
...>>>;
...>..;
..>>.>..;
..>>..>.>>;
..>>>>>>>;
...>..;
...>;
.;
...>>>.;
..>>...>>;
;
..;
.;
.;
>.>;
...>>.>.>>;
>...>;
..;
.;
;
;
..>;
;
;
;

Hexdump di codice

00000000: 2020 200a 2020 0909 2020 0920 0920 0a20
00000010: 2009 0909 090a 2020 2009 0a20 2020 0909
00000020: 090a 2020 2009 2020 0a20 2009 0920 0920
00000030: 200a 2020 0909 2020 0920 0909 0a20 2009
00000040: 0909 0909 0909 0a20 2020 0920 200a 2020
00000050: 2009 0a20 0a20 2020 0909 0920 0a20 2009
00000060: 0920 2020 0909 0a0a 2020 0a20 0a20 0a09
00000070: 2009 0a20 2020 0909 2009 2009 090a 0920
00000080: 2020 090a 2020 0a20 0a0a 0a20 2009 0a0a
00000090: 0a0a

Codice assembly spazi bianchi:

push 0      ;null
push -74    ;! chr(33)
push -7     ;d chr(100)
push 1      ;l chr(108)
push 7      ;r chr(114)
push 4      ;o chr(111)
push -20    ;W chr(87)
push -75    ;  chr(32)
push -63    ;, chr(44)
push 4      ;o
push 1      ;l
dup         ;l
push -6     ;e chr(101)
push -35    ;H chr(72)
p:
 dup jumpz e
 push 107 add printc
 jump p
e:
 exit

Osservazioni:

Ho dovuto scrivere un programma solo per calcolare che l'aggiunta di 107 dà il golf ottimale per la frase. Poiché la dimensione in byte che un intero accetta nel codice cambia. : 4 + int (abs (log2 ($ n)))
Il codice verrà comunque eseguito senza l'etichetta "e:" e uscirà da whitespace.kauaveel.ee . Ma ciò potrebbe rendere non valido il codice degli spazi bianchi su altri compilatori di spazi bianchi. Quindi quei byte non sono stati eliminati dalla soluzione.

Si dovrebbe notare che

Come ha sottolineato Kevin Cruijssen nei commenti, consentendo una "uscita per errore" come da meta, lo spazio bianco può essere codificato con più di 126 caratteri.

..>>..>.>.;
..>>>>;
...>;
...>>>;
...>..;
..>>.>..;
..>>..>.>>;
..>>>>>>>;
...>..;
...>;
.;
...>>>.;
..>>...>>;
;
..;
...>>.>.>>;
>...>;
..;
.;
;

Montaggio:

push -74
push -7
push 1
push 7
push 4
push -20
push -75
push -63
push 4
push 1
dup
push -6
push -35
label_0:
push 107
add 
printc
jmp label_0

Java, 79

class H{public static void main(String[]a){System.out.print("Hello, World!");}}

Le versioni precedenti di Java potrebbero consentire di utilizzare un blocco statico (51 byte), ma attualmente non conosco un modo per aggirare il mainmetodo.

CSS, 30 byte

:after{content:"Hello, World!"

CSS (Cascading Style Sheets) non è un tipico linguaggio di programmazione, ma può fare abbastanza bene l'output fisso. Questo viene fatto creando uno pseudo-elemento dopo ogni elemento con il contenuto Hello, World!. Quindi <html>è selezionato solo un elemento ( ), questo presuppone che stiamo usando il documento HTML più semplice, cioè

<html><style>:after{content:"Hello, World!"</style></html>

Funziona con la maggior parte dei browser principali, con la notevole eccezione di Firefox, che applica il selettore agli elementi <html>e <body>. Questo è anche il motivo per cui i frammenti di stack non funzionano, perché c'è sempre anche un elemento del corpo che viene stilizzato. Di seguito è una versione leggermente modificata da testare.

* :after{content:"Hello, World!"

HTML, 13 byte

Hello, World!

Il testo viene automaticamente inserito in <body>, e viene visualizzato.

codice macchina x86_64 per Linux, 32 byte

Quando Linux avvia un nuovo processo, tutti i registri (tranne RSP) sono zero, quindi possiamo ottenere RAX = 1 modificando solo il byte basso. L'ABI x86-64 System V non lo garantisce, ma è ciò che Linux fa effettivamente. Questo codice funziona solo come _startin un eseguibile statico.

0000000000000000 <_start>:
   0:   e8 0d 00 00 00          call   12 <hello>
   5:   48 65 6c 6c 6f
   a:   2c 20 57 6f 72
   f:   6c 64 21 5e 40

0000000000000012 <hello>:
  12:   5e                      pop    rsi
  13:   40 b7 01                mov    dil,0x1
  16:   b2 0d                   mov    dl,0xd
  18:   b0 01                   mov    al,0x1
  1a:   0f 05                   syscall
  1c:   b0 3c                   mov    al,0x3c
  1e:   0f 05                   syscall

L'istruzione call inserisce l'indirizzo successivo, che contiene la stringa world hello, nello stack. Inseriamo l'indirizzo della stringa in rsi.

Quindi gli altri argomenti sono impostati per un syscalla sys_write, che stampa la stringa.

Il programma termina con un syscalla sys_exit. sys_writerestituisce il numero di byte scritti, quindi i byte superiori di RAX sono zero dopo il primo syscall(a meno che non abbia restituito un errore), quindi mov al, 60ci dà RAX = __NR_exitin soli 2 byte.

Puoi rendere questo programma segfault chiudendo il suo stdout ( ./a.out >&-), quindi sys_write()tornerà -EBADF, il secondo syscalltornerà -ENOSYSe quindi l'esecuzione cadrà alla fine. Ma non abbiamo bisogno di gestire gli write()errori con garbo.

Esagonia , 37 32 byte

Avviso: darò una ricompensa di 500 rappresentanti alla prima persona che trova una soluzione valida in un esagono di lunghezza laterale 3 o una soluzione dimostrabilmente ottimale di lunghezza laterale 4. Se non riesci a trovare una tale soluzione ma riesco a battere il mio punteggio in un 4 esagono di lunghezza laterale (ottenendo più no-op alla fine del programma, che può essere omesso dal codice sorgente), sono disposto a dare anche una taglia più piccola per quello .

H;e;P1;@/;W;o;/l;;o;Q/r;l;d;2;P0

Provalo online!

Vi presento con orgoglio il mio secondo linguaggio di programmazione 2D, e (per quanto ne sappia) il primo linguaggio 2D in assoluto su una griglia esagonale.

Il codice sorgente non sembra molto 2D, vero? Bene, lo spazio bianco è facoltativo in Hexagony. Innanzitutto, il codice sorgente viene riempito con il numero esagonale centrato successivo con no-ops ( .). Il prossimo numero è 37, quindi inseriamo cinque no-op alla fine. Quindi il codice sorgente viene riorganizzato in esagono regolare:

   H ; e ;
  P 1 ; @ /
 ; W ; o ; /
l ; ; o ; Q /
 r ; l ; d ;
  2 ; P 0 .
   . . . .

Anche questo è eseguibile. Provalo online!

Hexagony ha un sacco di funzionalità piuttosto funky, tra cui 6 diversi puntatori di istruzioni e un layout di memoria che è il grafico a linee di una griglia esagonale, ma questo codice utilizza solo un IP e un bordo di memoria, quindi per ora non preoccupiamoci di questo.

Ecco una panoramica dei comandi pertinenti:

• Le lettere hanno appena impostato il bordo di memoria corrente sul loro valore ASCII
• ; stampa il valore corrente, modulo 256, come byte su STDOUT.
• / è un mirror che si comporta come ti aspetteresti (facendo sì che l'IP faccia una virata di 120 gradi).
• Le cifre funzionano come fanno in Labyrinth : moltiplicano la cella corrente per 10 e quindi si aggiungono.
• @ termina il programma.

Ora la cattura finale è che la sorgente avvolge tutte e 3 le coppie di bordi. Inoltre, se l'IP lascia la griglia attraverso uno dei sei angoli, ci sono due possibili file su cui saltare. Quale viene scelto dipende se il valore corrente è positivo o non positivo. La seguente versione annotata mostra dove rientra l'IP ogni volta che lascia la griglia:

         H ; e ;     -> 1
5 ->    P 1 ; @ /    -> 4
3 ->   ; W ; o ; /   -> 2
1 ->  l ; ; o ; Q /
4 ->   r ; l ; d ;   -> 5
2 ->    2 ; P 0 .    -> 3
         . . . .

Quindi se rimuoviamo tutti i cambi di direzione, questo programma si riduce al seguente codice lineare:

H;e;l;;o;Q2;P0;W;o;r;l;d;P1;@

Che cosa è con Q2, P0e P1? Le lettere vengono stampate facilmente perché possiamo semplicemente impostare il bordo sul valore corrispondente. Per la virgola, lo spazio e il punto esclamativo, non funziona. Inoltre, non può solo impostare il valore con 44, 32, 33, rispettivamente, perché il bordo memoria è diverso da zero per cominciare, e causa la semantica di cifre individuali che avrebbe causato ogni sorta di caos. Se volessimo farlo, avremmo dovuto reimpostare il valore bordo a zero con qualcosa di simile *, +, -, &o ^prima. Tuttavia, poiché il valore viene assunto modulo 256 prima di essere stampato, non è necessario impostare i valori esattamente su 44, 32 o 33. Ad esempio, se preso moduloQ2 imposteremo il valore del bordo su81*10 + 2 = 812 , che è44256. In questo modo possiamo salvare un byte su ciascuno di questi tre caratteri. (Purtroppo, non è mai possibile arrivare con una sola cifra dal valore della cella ha già. In modo divertente, dove si fa il lavoro è l' oin World, perché questo può anche essere ottenuta da W9.)

Puoi usare questo script CJam per trovare tutte le combinazioni di lettere e cifre che danno come risultato un dato carattere.

Non sono sicuro che sia ottimale. Dubito che sia possibile farlo in un esagono di lunghezza laterale 3 (dove avresti a disposizione solo 19 caratteri), ma potrebbe essere possibile risolverlo in un esagono con lunghezza laterale 4 con meno di 32 comandi, ad esempio che ci sono più no-op alla fine della griglia.

Malbolge, 112 byte

('&%:9]!~}|z2Vxwv-,POqponl$Hjihf|B@@>,=<M:9&7Y#VV2TSn.Oe*c;(I&%$#"mCBA?zxxv*Pb8`qo42mZF.{Iy*@dD'<;_?!\}}|z2VxSSQ

Vedrò se ce n'è uno più corto. Ho un computer migliore dall'ultima volta, quindi posso generare un po 'più veloce.

Per lo spettacolo, ecco "Hello World!" senza la virgola.

(=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8dc

Fourier , 15 byte

GRANDI CAMBIAMENTI a Fourier!

`Hello, World!`

Provalo su FourIDE!

Sì, i giorni in cui si digita il codice ASCII di ogni personaggio sono andati per sempre: Fourier ora po ' supporti stringhe. Quando si racchiude una stringa nei backtick, quella stringa verrà emessa.

Nota che non puoi fare altro che produrre quella stringa: non puoi memorizzarla in una variabile, non è memorizzata nell'accumulatore e non ci sono strumenti di manipolazione delle stringhe.

Qui puoi trovare il relitto del treno che era il vecchio Fourier. ;)

72a101a+7aa+3a44a32a87a111a+3a-6a-8a33a

Provalo online!

Ora, alcuni di voi avranno probabilmente incontrato Fourier prima e potrebbero avere una certa familiarità con la lingua. L'intero linguaggio si basa su un accumulatore: una variabile globale che praticamente tutti gli operatori usano.

La parte più importante del codice è l' aoperatore. Questo prende il valore numerico dell'accumulatore e lo converte in un carattere usando il codice Pythonchr(accumulator) . Questo viene quindi stampato su STDOUT.

Sfortunatamente, non ho ancora avuto la possibilità di usare Fourier ( nudge nudge , wink wink ), principalmente a causa della sua mancanza di stringhe e operatori di stringhe. Anche così, è ancora utilizzabile per molte altre sfide (vedi la sezione degli esempi della sua pagina EsoLangs).

Si noti che questo è più breve della mia entrata nell'elenco Esolangs perché in realtà non pensavo di poterlo giocare più a golf. E poi, quando ho scritto la sfida del golf a corda di Fourier, mi sono reso conto che avrei potuto andare un po 'più corto.

Nota

Se ti stavi chiedendo della sintassi delle variabili, Geobits ha scritto un programma che utilizza le variabili e ha la stessa lunghezza:

72a101a+7aa+3~za44a32a87aza+3a-6a-8a/3a

Provalo online!

C-- , 155 byte

target byteorder little;import puts;export main;section"data"{s:bits8[]"Hello, World!\0";}foreign"C"main(){foreign"C"puts("address"s);foreign"C"return(0);}

Sfortunatamente, l'unico compilatore C-- noto, Quick C-- non viene più mantenuto. Costruire un dolore al collo, ma è possibile ...

C, 30 byte

main(){puts("Hello, World!");}

Abbastanza vaniglia, ma non riesco a pensare a un modo comunemente compilabile per farlo in modo più breve (a meno che forse un qualche tipo di asm raw possa funzionare?). Comunque, batte la maggior parte degli esolang!

Illeggibile , 843 755 732 666 645 629 577 byte

' ' ' '''' ' ' ''''' " ' '' '' '''" "' '' ' ' '''' ' ' '''' ' ' ''''"' '' ' ' ' '''' '' '' ' ' '''' ' ' '''' ''' "" ' ''' "" ' ''' "" ' ''' "" ' ''' "" ' ''' "" ' ''' "" ' '' '' ''' "" ' ''' "" " ' '''" " ' '''" " ' '''" "' "" ' '''" " ' '''" " ' '''" " ' '''" " ' ' ' '''' ' ' '''' ' ' '''' ' ' '''' " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" "' "" ' ''' "" ' ''' "" "" "" ' '' '' '' ''' "" " ' '''" " ' '''" " ' '''" "' "" ' '''" " ' '''" " ' '''" "" "" " ' '' ' ' '''' ' ' '''' ' ' '''' ' ' '''' " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" " ' '''" "' "" ' ''' "" ' ''' "" ' ''' "" ' '' " ' ' ' '' '' '' ' ' '' '' '' '''' '''''"" "" "" "' ''" '"' '' '' '' ' ' '''' "' '' ' ' ' ' '''' ' ' ''''''" ' '' ' ''' "" "" "" " ' '''" "" ' ' ' '' '' '' ' ' '''' ''''' "" "" "" " ' '''" " ' '''" "" ' ' ' '''' '' '' ''' """"" ' '' ' ' ' ' '''' ' ' '''''' ' ' '''' ' ' '' '' '' ' ' '''' ''''' "" "" "" " ' '''" "" ' ' ' '' '' '' ' ' '''' ' ' '''' ''''' "" ' '' '' '' "' ''""" ' '' ' ' ' ' '''' ' ' '''''' ' ' '''' ' ' '' '' '' ' ' '''' ''''' "" "" "" " ' '''" "" ' ' ' '' '' '' ' ' '''' ' ' '''' ''''' "" ' '' '' '' "' ''""" " ' '''" "" ' ' ' '' '' '' ' ' '''' ' ' '''' ''''' "" ' '' '' '' "' ''""" " ' '''" "" ' ' ' '' '' '' ' ' '''' ' ' '''' ''''' "" ' '' '' '' "' ''"

I programmi illeggibili dovrebbero essere visualizzati con un carattere a larghezza variabile, quindi rispettano il nome della lingua. Sono leggermente deluso dal fatto che i miei approcci più sofisticati si siano rivelati molto più lunghi. I loop sono follemente costosi in Illeggibile ...

Provalo online!

Come funziona

Illeggibile ha solo dieci funzioni; sei di questi sono usati in questo codice:

'"        p Print.
'""       + Increment.
'"""      1 Return 1.
'""""""   : Set.
'"""""""  = Get.
'"""""""" - Decrement.

Dopo aver usato la mia notazione a carattere singolo e aver aggiunto spazi bianchi e commenti, il codice sopra appare come il seguente. Le istruzioni multilinea vengono eseguite dal basso verso l'alto.

p+++                                        Print 3 + variable 2 (o).
 pp                                         Print variable 2 two times (l).
  :+1+++++++                                Save 8 + variable 3 in variable 2.
   p+                                       Print 1 + variable 3 (e).
    :++1+++++++++++++                       Save 13 + variable 4 in variable 3.
     :+++1+++++++++++++++                   Save 43 + variable 0 in variable 4.
      p++++++++++++++++++++++++++++         Print 28 + variable 0 (H).
       :-1++++++++++++                      Save 44 in variable 0.
        :1+++++++++++++++++++++++++++++++1  Save 32 in variable 1.
p=-1                                        Print variable 0 (,).
p=1                                         Print variable 1 ( ).
p=+++1                                      Print variable 4 (W).
p+++                                        Print 6 + variable 2 (r).
 p+++=+1                                    Print 3 + variable 2 (o).
p=+1                                        Print variable 2 (l).
p=++1                                       Print variable 3 (d).
p+=1                                        Print 1 + variable 1 (!).

Ho generato il codice sorgente effettivo eseguendo la versione non commentata dello pseudocodice sopra tramite questo programma CJam .

Befunge 98 , 19 18 byte

Nuova risposta (da undergroundmonorail)

"ck,@!dlroW ,olleH

Spiegazione

• " avvia la modalità stringa
• Tutto ciò che segue viene inserito nello stack. Lo stack è oraHello, World!@,kc
• Dopo aver colpito la fine, l'interprete torna all'inizio
• Si incontra di "nuovo, terminando la modalità stringa
• 12 viene inserito nello stack ( c)
• k prende il massimo valore dello stack ed esegue il comando successivo che il puntatore dell'istruzione può vedere più volte
• ,estrae un valore dallo stack e lo emette come carattere. È stata eseguita 12 volte dall'ultima kistruzione e ancora una volta quando l'interprete legge effettivamente l' ,istruzione
• @ termina il programma

La differenza con la vecchia risposta è che riusiamo abilmente il "personaggio usando il comportamento in loop di Befunge quando raggiunge la fine della linea. Dal momento che potrebbe essere meno intuitivo, sto lasciando che anche il vecchio. Inoltre, potresti aver notato che lo stack conterrà ancora alcuni caratteri (ck,@ ) a causa di questo bel trucco, lasciando un po 'di casino se mai avessimo voluto fare qualcosa dopo.

Vecchia risposta

"!dlroW ,olleH"ck,@

Funziona con Funge and Befunge 98

Spiegazione

• Tutto tra ""viene spinto in pila. ( 'H'ora è in cima.)
• c (12) viene inserito nella pila
• k prende il massimo valore dello stack ed esegue il comando successivo che il puntatore dell'istruzione può vedere più volte.
• ,estrae un valore dallo stack e lo emette come carattere. È stata eseguita 12 volte dall'ultima kistruzione e ancora una volta quando l'interprete legge effettivamente l' ,istruzione
• @ termina il programma

JSFuck , 6293 6289 6277 byte

Questo potrebbe essere menzionato come uno dei più lunghi "programmi Hello, World! " Più brevi (in realtà non so se sia ottimale, ma è il più breve che sono riuscito a ottenere).

Attenzione: funziona solo con Firefox e Safari

[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()(!![])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]](([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[+[]])())[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]+(![]+[])[!![]+!![]]+([][[]]+[])[!![]+!![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]]+[])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()((+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[])+(+[]))+[])[+[]]+![])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]))()

Esiste anche una versione leggermente più lunga (+4 byte) che funziona anche in Chrome e Microsoft Edge:

[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([(![]+[])[+!![]]+(![]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()(!![])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]]((![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]]+(![]+[])[+[]])())[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]+(![]+[])[!![]+!![]]+([][[]]+[])[!![]+!![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()((+(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[])+(+[])+(+[]))+[])[+[]]+![])[+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]()[+!![]+[!![]+!![]]]+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]))()

Per chi non ha familiarità con JSFuck, si tratta di scrivere JavaScript come se ci fossero solo sei caratteri, e a volte può diventare piuttosto pazzo.

Questa tabella mostra come i personaggi utilizzati in Hello, World! i programmi sono codificati in JSFuck. Il semplice codice di testo è giusto alert("Hello, World!").

+----------+--------------------------------------+---------------------------+
|JavaScript|               write as               |           JSFuck          |
+----------+--------------------------------------+---------------------------+
|     a    | (false+[])[1]                        | (![]+[])[+!![]]           |
|     l    | (false+[])[2]                        | (![]+[])[!![]+!![]]       |
|     e    | (true+[])[3]                         | (!![]+[])[!![]+!![]+!![]] |
|     r    | (true+[])[1]                         | (!![]+[])[+!![]]          |
|     t    | (true+[])[0]                         | (!![]+[])[+[]]            |
|     (    | ([]+[]["fill"])[13]                  | 114 bytes                 |
|     "    | ([]+[])["fontcolor"]()[12]           | 539 bytes                 |
|     H    | btoa(true)[1]                        | 1187 bytes                |
|     o    | (true+[]["fill"])[10]                | 105 bytes                 |
|   space  | ([]["fill"]+[])[20]                  | 107 bytes                 |
|     W    | (NaN+self())[11]                     | 968 bytes                 |
|     d    | (undefined+[])[2]                    | ([][[]]+[])[!![]+!![]]    |
|     !    | atob((Infinity+[])[0]+false)[0]      | 1255 bytes                |
|     )    | (0+[false]+[]["fill"])[20]           | 114 bytes                 |
+----------+--------------------------------------+---------------------------+

Qui le stringhe "fill", "fontcolor"ecc. Devono essere scritte come "f"+"i"+"l"+"l", "f"+"o"+"n"+"t"+"c"+"o"+"l"+"o"+"r"per essere codificate.

Gli identificatori globali self, atobe btoavengono scritti comeFunction("return self")() .

Functionstesso dovrebbe essere []["fill"]["constructor"].

La virgola ","è complicata, non sono sicuro al 100% di come funzioni ma utilizza la []["concat"]funzione per creare un array. Pubblicherò un aggiornamento quando avrò tempo di fare altri test.

L'ho codificato usando JScrewIt - crediti a GOTO 0 per la creazione di uno strumento così sofisticato:

• Apri Firefox (puoi scegliere qualsiasi altro browser, ma il solo codice Firefox è il più breve.)
• Passare a JScrewIt : http://jscrew.it
• Ingresso: alert("Hello, World!")
• Codice eseguibile: selezionato
• Compatibilità: solo questo browser

Ciò differisce dalla mia risposta a questa domanda per la presenza della virgola dopo "Ciao".

È interessante notare che la sintassi ES6

alert`Hello, World!`

impiega ancora più byte per codificare (+1500 o giù di lì) a causa della maggiore complessità della codifica di due backtick anziché ("e ").

Pada , 83 68 byte

~.O~Ow~q~Owo~O~Oww~Q~qwo~q~O~wQ~q~w~q~q~Q~Ow~Q~Q~wo~q~w.~q~w.~.wO~qw

Credo che questo sia ottimale per un programma lineare (cioè uno che non utilizza gli operatori del flusso di controllo ?e *). Nel complesso potrebbe essere ottimale, ma non so come fare per utilizzare quegli operatori aggiuntivi con una quantità così piccola di codice (o come esplorare le possibilità a livello di codice).

La lingua ha recentemente subito alcune modifiche dopo che ho iniziato a discuterne con l'autore via e-mail. Tuttavia, ho scritto un'implementazione di riferimento per lo stato corrente delle specifiche della lingua la scorsa settimana, quindi il codice sopra è effettivamente eseguibile.

Metagolf

Inizialmente, avevo utilizzato l'output della mia implementazione di riferimento per questa sfida e creato una soluzione artigianale basata su quello. Tuttavia, quello era solo un approccio euristico.

Così invece ho scritto un risolutore in Mathematica che in realtà conosce le strutture dati e gli operatori di Pada per trovare una soluzione ottimale. In media, cresce in modo lineare con la lunghezza della stringa (anche se alcune combinazioni di caratteri sono un po 'più lente di altre) e richiede circa 1,5 ore Hello, World!.

Quindi, come ho fatto a scrivere il risolutore. Innanzitutto, notiamo che dobbiamo considerare solo 6 operatori: ~.oOqQ(più il necessario wper ciascuno dei caratteri stampati). L'uso degli stack o dei blocchi di bit non è utile nel codice lineare e non ci credo ?e *può essere utilizzato in modo efficace in meno di 68 byte.

Lo stato di Pada (ignorando le pile e i blocchi) è composto da 7 interruttori e 8 bit, disposti in questo modo:

       /
   /       \
 /   \   /   /
0 1 0 0 1 0 0 0

Quindi questo è possibile stati. Il mio primo passo di preelaborazione è stato quello di impostare un grafico diretto degli stati in cui ogni fronte corrisponde a una singola operazione. Cioè, il grafico ha 32768 vertici, ciascuno con un grado esterno 6 (un bordo in uscita per ciascuna delle 6 operazioni in esame). Possiamo usare questo grafico per trovare il percorso più breve tra due stati (questo grafico da solo può essere abbastanza utile per giocare a golf a Pada).215 = 32768

Ora per ogni personaggio, vogliamo raggiungere uno stato in cui wstampa quel personaggio. Quanti di questi stati ci sono? wlegge il byte dal bit sul quale viene rilasciato (ciclicamente). Quindi ci sono 8 possibili rotazioni dei bit del personaggio che possono tutti stampare quel personaggio. Per ciascuna di queste rotazioni, sono fissati tre interruttori (per far wcadere nella posizione corretta). Questo lascia 4 interruttori arbitrari. Quindi abbiamo stati possibili per ciascuno nel nostro codice.8 * 24 = 128w

Con quelli possiamo risolvere un altro problema del grafico: costruire un grafico che ha un vertice sorgente, quindi uno "strato" per ciascun personaggio e un vertice sink. I layer sono costituiti dai 128 stati per ciascun vertice, il nodo sorgente corrisponde allo stato iniziale del programma (tutti gli switch a sinistra e tutti i bit sono zero). Il nodo sink corrisponde a nessuno stato in particolare. Abbiamo bordi diretti da ogni vertice di un livello a ogni vertice del livello successivo, in cui il peso del bordo è la distanza tra i due stati nel nostro grafico precedente. I pesi dei bordi dall'ultimo strato al lavandino sono tutti 0. In altre parole, possiamo precalutare tutti quei pesi dei bordi. Questo è il passaggio più costoso del calcolo e ha impiegato 1,5 ore Hello, World!.

Con questo grafico impostato, possiamo trovare il percorso più breve dalla sorgente al lavandino abbastanza rapidamente (ci sono voluti 0,05 secondi sulla mia macchina). Per Hello, World!gli stati desiderati sono:

0, 16960, 22052, 13828, 13828, 30389, 12487, 8307, 27299, 23450, 18922, 22778, 18682, 18459

dove i 7 bit meno significativi corrispondono agli interruttori e gli 8 bit più significativi ai bit di Pada.

Ora torniamo al primo grafico e troviamo i bordi effettivi (cioè le operazioni) corrispondenti al percorso più breve tra ciascuna coppia di stati successivi e terminiamo ciascuno con un w. Voilà, una soluzione ottimale (basata sui presupposti di cui sopra).

Ecco la completa Mathematica se qualcuno vuole mai metagolf una stringa diversa in Pada:

string = "Hello, World!";
width = StringLength@string;
getState[letter_, state_] := (
  {shift, switchState} = IntegerDigits[state - 1, 16, 2];
  bits = RotateRight[
    IntegerDigits[ToCharacterCode[letter][[1]], 2, 8], shift];
  switchState = IntegerDigits[switchState, 2, 4];
  switches = {-1, -1, -1, -1, -1, -1, -1};
  {top, middle, bottom} = IntegerDigits[shift, 2, 3];
  switches[[1]] = top;
  If[top < 1,
   switches[[2]] = middle;
   If[middle < 1,
    switches[[4]] = bottom,
    switches[[5]] = bottom
    ],
   switches[[3]] = middle;
   If[middle < 1,
    switches[[6]] = bottom,
    switches[[7]] = bottom
    ]
   ];
  For[i = 1, i <= 7, ++i,
   If[switches[[i]] < 0,
    switches[[i]] = First@switchState;
    switchState = Rest@switchState
    ]
   ];
  {bits, switches}
  )
encode[state_] := FromDigits[Join @@ state, 2]
decode[id_] := Partition[IntegerDigits[id, 2, 15], 8, 8, 1, {}]
getBitFromSwitches[switches_] := (
  If[switches[[1]] < 1,
   If[switches[[2]] < 1,
    1 + switches[[4]],
    3 + switches[[5]]
    ],
   If[switches[[3]] < 1,
    5 + switches[[6]],
    7 + switches[[7]]
    ]
   ]
  )
toggle[list_, index_] := ReplacePart[list, index -> 1 - list[[index]]]
stateEdges = Flatten@Table[
    {bits, switches} = decode@id;
    bit = getBitFromSwitches@switches;
    {
     Labeled[id \[DirectedEdge] encode@{bits~toggle~bit, switches}, 
      "~"],
     Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~1}, "."],
     If[switches[[1]] < 1,
      {
       Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~2}, 
        "o"],
       Labeled[
        id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~3}, 
        "q"],
       If[switches[[2]] < 1,
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~4}, 
         "O"],
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~5}, 
         "O"]
        ],
       If[switches[[3]] < 1,
        Labeled[
         id \[DirectedEdge] 
          encode@{bits, switches~toggle~1~toggle~3~toggle~7}, "Q"],
        Labeled[
         id \[DirectedEdge] 
          encode@{bits, switches~toggle~1~toggle~3~toggle~6}, "Q"]
        ]
       },
      {
       Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~3}, 
        "o"],
       Labeled[
        id \[DirectedEdge] encode@{bits, switches~toggle~1~toggle~2}, 
        "q"],
       If[switches[[3]] < 1,
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~6}, 
         "O"],
        Labeled[id \[DirectedEdge] encode@{bits, switches~toggle~7}, 
         "O"]
        ],
       If[switches[[2]] < 1,
        Labeled[
         id \[DirectedEdge] 
          encode@{bits, switches~toggle~1~toggle~2~toggle~5}, "Q"],
        Labeled[
         id \[DirectedEdge] 
          encode@{bits, switches~toggle~1~toggle~2~toggle~4}, "Q"]
        ]
       }
      ]
     }
    ,
    {id, 0, 2^15 - 1}];
stateGraph = 
  Graph[# & @@@ stateEdges, EdgeLabels -> Rule @@@ stateEdges];
uid = 0;
layers = Join[{{{uid++, 0}}}, 
   Table[{uid++, encode@getState[#, i]}, {i, 128}] & /@ 
    Characters@string, {{{uid++, -1}}}];
edges = Flatten[Table[
      from \[DirectedEdge] to
      ,
      {from, #},
      {to, #2}
      ] & @@@ Partition[layers, 2, 1], 2];
Timing[weights = (
     {from, to} = Last /@ List @@ #;
     If[to < 0,
      0,
      GraphDistance[stateGraph, from, to]
      ]
     ) & /@ edges;]
characterGraph = Graph[edges, EdgeWeight -> weights];
Timing[path = 
  Last /@ Most@
    FindShortestPath[characterGraph, {0, 0}, layers[[-1]][[1]]]]
(PropertyValue[{stateGraph, #}, EdgeLabels] & /@ 
      DirectedEdge @@@ 
       Partition[FindShortestPath[stateGraph, ##], 2, 1] <> "w" & @@@ 
   Partition[path, 2, 1]) <> ""