Então ... isso é um pouco embaraçoso. Mas não temos um simples "Olá, mundo!" desafio ainda (apesar de ter 35 variantes marcadas com hello-world e contando). Embora este não seja o código de golfe mais interessante nos idiomas comuns, encontrar a solução mais curta em certos esolangs pode ser um sério desafio. Por exemplo, que eu saiba, não se sabe se a solução Brainfuck mais curta possível já foi encontrada.

Além disso, enquanto toda a Wikipedia (a entrada da Wikipedia foi excluída, mas há uma cópia em archive.org ), esolangs e Rosetta Code têm listas de "Olá, Mundo!" programas, nenhum deles está interessado em ter o menor para cada idioma (também existe este repositório GitHub ). Se queremos ser um site importante na comunidade de código-golf, acho que devemos tentar criar o catálogo definitivo dos mais curtos "Olá, mundo!" programas (semelhante à forma como nosso desafio básico sobre quine contém alguns dos quines mais curtos conhecidos em vários idiomas). Então vamos fazer isso!

As regras

• Cada envio deve ser um programa completo.
• O programa não deve receber nenhuma entrada e imprimir Hello, World!em STDOUT (esse fluxo de bytes exato, incluindo maiúsculas e pontuação), além de uma nova linha de rastreamento opcional e nada mais.
• O programa não deve gravar nada no STDERR.

• Se alguém quiser abusar disso criando uma linguagem em que o programa vazio é impresso Hello, World!, então parabéns, eles apenas abriram o caminho para uma resposta muito chata.

  Observe que deve haver um intérprete para que o envio possa ser testado. É permitido (e até encorajado) escrever esse intérprete para um idioma anteriormente não implementado.

• As submissões são pontuadas em bytes , em uma codificação apropriada (pré-existente), geralmente (mas não necessariamente) em UTF-8. Alguns idiomas, como Pastas , são um pouco difíceis de pontuar - em caso de dúvida, pergunte no Meta .
• Não se trata de encontrar o idioma com o menor "Olá, mundo!" programa. Trata-se de encontrar o menor "Olá, Mundo!" programa em todas as línguas. Portanto, não marcarei nenhuma resposta como "aceita".
• Se o seu idioma de escolha for uma variante trivial de outro idioma (potencialmente mais popular) que já tenha uma resposta (pense em dialetos BASIC ou SQL, shell do Unix ou derivados triviais do Brainfuck como Alphuck), considere adicionar uma nota à resposta existente de que o solução igual ou muito semelhante também é a mais curta no outro idioma.

Como observação lateral, por favor , não reduza as respostas chatas (mas válidas) em idiomas onde não há muito para jogar golfe - elas ainda são úteis para esta pergunta, pois ela tenta compilar um catálogo o mais completo possível. No entanto, fazer respostas principalmente upvote nas línguas em que os autores realmente tive que colocar esforço para jogar golfe o código.

Para inspiração, confira a coleção Hello World .

O Catálogo

O snippet de pilha na parte inferior desta postagem gera o catálogo a partir das respostas a) como uma lista da solução mais curta por idioma eb) como uma tabela geral de líderes.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

## Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no 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>

Preso, 0 bytes

Bem, não pode ficar mais curto que isso ... Um programa vazio será exibido Hello, World!no Stuck .

PHP, 13 bytes

Hello, World!

Sim. Funciona.

Brainfuck, 78 bytes

Recompensa em aberto: se alguém puder melhorar essa pontuação, passarei a recompensa (+500) para eles. A @KSabencontrou umasolução de 76 72 bytes!

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

Experimente online!

Os primeiros 28 bytes --<-<<+[+[<+>--->->->-<<<]>]inicializam a fita com a seguinte relação de recorrência (mod 256):

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

O fator 171 surge porque 3 ^-1 ± 171 (mod 256) . Quando o valor atual é convertido, uma célula volta (via <+>---) subtraindo 3 cada vez que multiplica efetivamente o valor por 171.

Em n = 220, o valor a ser traduzido é zero e a iteração para. Os dez bytes anteriores ao ponto de parada são os seguintes:

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

Ele contém todos os componentes necessários para produzir Hello, World!, de maneira caçada e picada, com pequenos ajustes.

Eu também encontrei uma solução alternativa de 78 bytes:

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

Experimente online!

Considero que este é melhor que o primeiro por várias razões: usa menos células restantes de casa, modifica menos células no total e termina mais rapidamente.

Mais detalhes

Relações de recorrência têm representações surpreendentemente concisas em Brainfuck. O layout geral é o seguinte:

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

que representa:

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

com

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

Além disso, <+>pode ser alterado para multiplicar o intervalo por uma constante sem afetar o ponto de parada, e um termo pode ser adicionado antes >{k}de alterar o intervalo por uma constante, novamente sem afetar o ponto de parada.

Outros exemplos

Sequência de Fibonacci

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

Números gonais

Números triangulares

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

Definido como f _n = 2 · f _n-1 - f _n-2 + 1 , com f ₀ = 0 , f ₁ = 1 .

Números quadrados

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

Números pentagonais

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

etc.

BF Crunch

Publiquei o código que usei para encontrar algumas dessas soluções no github . Requer .NET 4.0 ou superior.

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.

A saída é dada em três linhas:

1. Duração total do programa encontrado e o segmento de inicialização.
2. Caminho percorrido, começando com o ponteiro da fita atual. Cada nó corresponde a um caractere de saída, representado como (ponteiro, custo).
3. Segmento de fita utilizado.

Por exemplo, o resultado final para 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

Isso corresponde ao programa completo:

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

Outros registros

Olá Mundo!

Embrulho, 78 bytes :

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

ou

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

Sem quebra automática , 87 bytes (anteriormente 92 bytes (mitchs) ):

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

Olá Mundo!

Embrulho, 80 bytes :

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

Sem quebra automática, 81 bytes (anteriormente 92 bytes (hirose) ):

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

Olá Mundo!

Embrulho, 74 bytes :

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

Sem quebra automática, 84 bytes :

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

Versão Esolangs

Olá mundo! \ N

Embrulho, 76 bytes :

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

Isso usa uma célula deixada em casa e, portanto, seria considerada 77.

Sem quebra automática, 83 bytes :

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

Rdebath aprovado . saída 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)

Olá Mundo!

Embrulho, 70 bytes (anteriormente 78 ¹ ):

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

Sem quebra automática, 77 bytes (anteriormente 89?):

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

O autor afirma que o mais curto código de mão "Olá Mundo!" tem 89 bytes, mas não fornece referência. Por meio deste, reivindico o registro para isso também.

Olá Mundo!

Invólucro, 65 bytes (anteriormente 66 bytes):

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

Na verdade, isso também é codificado à mão (o melhor que eu poderia encontrar pela trituração é 68 bytes ). A primeira célula é inicializada para 259 (3) e diminuída por 7 a cada iteração, repetindo 37 vezes. A célula seguinte é decrementada por 6, resultando em 256 - 6,37 = 34 . O restante das células é decrementado em 4 a cada vez, adicionando uma célula a cada iteração, com cada nova célula inicializada para 252 (-4). O resultado é o seguinte:

[  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, ...]

¹ A solução fornecida (79 bytes) pode ser trivialmente reduzida em um:

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

ArnoldC , 71 bytes

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

Apenas para risos ..

Semente , 6016 4234 4203 bytes

20 854872453003476740699221564322673731945828554947586276010721089172712854441839676581917455319274850944955030258951339804246125714958815519550291630078076933441706558540342671975808828643360922071900333028778314875248417953197990571991784126564752005357199892690656368640420204822142316716413192024742766282266114842280731756458212469988291309261528542889299297601723286769284159107438930448971911102280330101196758384815655479640836157495863547199726234352265518586460633795171196315255736880028338460236768181141732764911402112878175632130129852788301009582463631290071329795384336617491655825493435803011947670180368458659271192428341035912236946048939139042310380278430049252171822721598175984923434205610723412240162418996808671543770639111617709604242882388664919702606792443015941265168129550718541372361144081848761690730764968771245566074501485020726368378675085908872608679630368472956274468410052703615106090238423979678950131481176272880569100533049143775921798055136871254424261001442543122666701145111965968366507060931708140304772342855064834334129143038575569044150428480231956133612367393837580345180691911525531699573096952433882387811884727975431823620782822755161559988205401134640722220804177812794328129589949692446031008866917615922944976151073653201316255518389496411696741029209242119521978920200314572718584995265523235225587228975886710511855501710470163649632761488899317729943053884132314641377747687975638119132094777769497069556255954031537245957811105217875011509899497752696062748928963281605780942517262774976217663461063680912331030221981433051827519906741285738915397005702326447635845195923640649166530310494885569783989508000344280715868581532826832242144647203531393142251025361866506821695860883605004105862208004440476654027574832078603305884731766236740069411566854496824754558761536201352147934963241039597221404341132342297870517293237489233057335406510464277610336142382379135365550299895416613763920950687921780736585299310706573253951966294045814905727514141733220565108490291792987304210662448111170752411153136765318541264632854767660676223663544921028492602135525959428999005153729028491208277493747933069008199074925710651071766675870081314909460661981433426167330215548196538791617762566403934129026219366764038390123622134753742930729751695349588862441999672547791630729398908283091638866715502470152431589429837867944760012419885615525232399584379209285060418518373512154801760060312646951597932345591416241634668119867158079946680321131213357200382937049485606706114467095019612014749723443159443363662563254359712162432143334612180576945072905749883870150120687696027984317320305291407322779803583395375616762530641605634303022155218169343410634115050596030685041633824154135240376022159918501703555881290333205131375705406831260759974112248490451605422031345264183102048614606636275942039438138959188478277971377232005036301145411215067576576667743288951344423152531417111852584846747428443123174595987315325304540564683047858415059703724263652136185848573853965992798725654430360647040362341567082462847275277303225817689141675391972818943419663764371222973269129542760661385278009266471167618553065823580448848795731295589715602705860758954890415040763604082216728159486423396295188510311881004469017351709060492844398219491990895826924575575549615118821417543037296628825303328056839433114519945243963946989899508355224823109677424196639930153649890175062456649384605721510239142861693109687536600667811037619175927995599388547421689316110236566026931360164495251160997857372500940728057700473763884480342708897319990346726967220426504612260565552531158509215849649565188655100774748485416791517853427613458459889062942881409801879085054494129489535044719193283409051007851153504224002807392992520076910314763705776345053922387355156981872691537772657428096384535960466923475731297217863371650154415835785630016335858514130863258775100537612371430357576913148500310344278511588325852376442503898849856566716198848377379400158332792027967216204970114516984638014129252882482309132898416484525230488700253065644547798869056136044415413099076332059572505138116227535024546891015836838323022822272664771489129085797354578016574544759934333471793

O programa Befunge-98 resultante (com base nisso ) é

"9!dlroW ,olleH"ck,@

Mornington Crescent , 3614 3568 bytes

Agradecemos a NieDzejkob por salvar 46 bytes usando nomes de linhas mais curtos.

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

Experimente online!

Isso certamente é subótimo, mas é metade do tamanho da solução em esolangs.

Hello, World é construído dividindo os seguintes nomes de estações e concatenando os resultados:

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

Finalmente, estou calculando o código de caractere de !as (2<<4)+1 == 33. Todas essas peças são concatenadas em Paddington e finalmente impressas em Mornington Crescent.

Nota: O idioma não especifica se é possível viajar para a mesma estação duas vezes seguidas, mas o intérprete permite, então eu o usei.

mal , 70 bytes

aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

Ele usa os quatro comandos a seguir:

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 bytes

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

Experimente online!

E a solução original de 76 bytes, sem embalagem :

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

Experimente online!

Outras soluções mais curtas conhecidas (que eu saiba) que encontrei

'Olá Mundo!' 77 bytes:

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

Experimente online!

'Olá Mundo!' 70 bytes:

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

Experimente online!

Eles foram encontrados usando um programa c ++ que escrevi aqui: https://github.com/ksabry/bfbrute

Nota: Originalmente, eu queria limpar esse código antes de publicá-lo, para torná-lo realmente um pouco legível e utilizável, mas como eu não o entro há mais de um ano, acho que vou publicá-lo como está. Ele faz uso pesado de modelos e constantes de tempo de compilação para possíveis otimizações e possui vários códigos comentados dos meus testes, mas nenhum comentário útil é desculpa, mas é um pouco horrível.

Não há nada terrivelmente inteligente sobre o código, é o forcer bruto em seu núcleo, no entanto, é bastante otimizado. A principal otimização é que ele itera primeiro todos os programas sem loops (nenhum [ou ]) até um comprimento especificado (16 atualmente) e armazena em cache uma matriz de todas as alterações que ela fará na matriz de dados. Ele armazenará apenas um único programa por matriz única de alterações, por exemplo, apenas uma delas >+<<->e <->>+<será armazenada. Ele itera através de todos os programas possíveis que são compostos de qualquer programa nesse cache com qualquer combinação de loops entre eles. Depois de executar cada programa, ele faz uma simples caça e ganância nos personagens e acrescenta isso ao final do programa.

Depois de executar isso no espaço de todos os programas, notei que quase todos os programas mais curtos (de até 19 anos) eram do formato *[*[*]*]. Restringir a pesquisa a programas deste formulário acelerou a pesquisa consideravelmente. O atual detentor do registro foi encontrado no comprimento 27. Na verdade, este foi calculado para o comprimento 74, mas notei uma sequência específica .>.>.>.que teve a sorte de ter um 0 na célula de dados à sua direita, permitindo que fosse simplificado para [.>]<reduzi-lo para 72.

Deixei que funcione por um bom tempo e completei a pesquisa com os parâmetros atuais até o comprimento 29, suspeito que será difícil superar o atual simplesmente subindo mais alto, acho que a abordagem mais promissora provavelmente aumentaria o espaço de pesquisa em alguma maneira inteligente.

Piet, 90 codéis

Esta é uma imagem 30 por 3. Alternativamente, no tamanho do codel 10:

O usa um layout de 3 alto, para que eu só precise apontar uma vez. Se isso ainda é jogável, eu provavelmente poderia fazer a barba no máximo em outra coluna, já que há um não-op de empurrar lá.

Edit: a solução de codel de 84 da @ primo .

Palheiro , 17 bytes

O Haystack é uma linguagem de programação 2D que é executada até encontrar a agulha no palheiro |, enquanto executa operações baseadas em pilha. Todos os programas iniciam no canto superior esquerdo e podem usar os caracteres direcionais><^v para se mover pelo programa. A direção é herdada; portanto, você não precisa continuar usando >para ir para a direita; a direção só mudará quando atingir um caractere direcional diferente.

Por padrão, o intérprete lê do canto superior esquerdo, indo para a direita, para que possamos colocar "Olá, mundo!" na pilha, use-a opara imprimi-la e coloque a agulha para concluir a execução.

"Hello, World!"o|

Bônus: Uma versão mais emocionante:

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

Ajuda, WarDoq! , 1 byte

H

Não apenas ajuda, WarDoq! Se você tiver um recurso interno para as grafias mais comuns da frase, ele ainda satisfaz nossa definição usual de linguagem de programação.

Experimente no intérprete online oficial (o código entra em Input ).

MarioLANG , 259 249 242 240 235 bytes

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

Isso foi testado na implementação do Ruby .

Depois de ofuscar "Olá, Mundo!"no MarioLANG, eu pensei em jogar um pouco. O acima é o mais curto que encontrei até agora.

Como antes, comecei a partir de uma solução Brainfuck que define quatro células para o múltiplo mais próximo de 10 para os caracteres He,e o espaço e o converteu no MarioLANG . Em seguida, você pode reduzir um pouco o código usando o piso auxiliar no loop, que quase reduz pela metade a largura do loop. Observe que a parte inferior é executada apenas uma vez a menos que a parte superior, para que você não obtenha mais múltiplos exatos do contador inicial em todas as quatro células.

Por fim, eu queria usar o espaço desperdiçado na frente do loop, então adicionei vários elevadores para fazer uso do espaço vertical lá. E então eu percebi que poderia dobrar o código depois o loop (consulte a revisão anterior) abaixo do loop para usar um pouco mais de espaço vertical, que economizou mais cinco bytes.

Provavelmente ainda está longe de ser perfeito, mas acho que é uma melhoria decente em relação à solução ingênua.

Metagolf

Tempo para alguma automação ...

Comecei a configurar um solucionador no Mathematica para encontrar uma solução ideal. Atualmente, assume-se que a estrutura do código é fixa: contador definido para 12, 4 células para impressão, com a atribuição fixa He,<space>e a mesma ordem dessas células. O que varia é o número de +s no loop, bem como as correções necessárias posteriormente:

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
 ]

Acontece que, para um contador inicial de 12, minha solução artesanal já é ótima. No entanto, o uso de 11 salva dois bytes. Tentei todos os valores de contador de 6 a 20 (inclusive) com os seguintes resultados:

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: Este solucionador supõe que o código linear após o loop esteja na linha superior, e o código acima é a solução dobrada. Pode haver uma solução geral mais curta, tornando o solucionador ciente da dobra, porque agora eu recebo mais 3 +s na primeira parte de graça, e as próximas 4 instruções custariam apenas 1 byte em vez de 2.

Escuro , 106 bytes

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

Vou deixar algumas citações da especificação da linguagem falarem pelo brilho deste esolang:

Dark é uma linguagem baseada na manipulação de mundos e dimensões inteiros para alcançar objetivos e construir a melhor realidade torturante possível.

Sempre que ocorre um erro de sintaxe, a sanidade do programa diminui em 1. [...] Se a sanidade do programa atingir zero, o intérprete fica louco.

A corrupção vira um único bit na variável quando ocorre.

Quando o mestre morre, todas as variáveis ​​de servidor anexadas a esse mestre também morrem. Isso é útil para agrupar e matar variáveis ​​em massa.

Força uma variável a se matar, libertando-a (lembre-se, porém, de que ela deixará a decomposição).

Define uma variável para um valor aleatório. Usa o Global Chaos Generator.

Se um stalker não for inicializado, qualquer tentativa de executar E / S resultará na diminuição das mensagens de erro a serem gravadas no console.

Homespring , 58 bytes

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

O espaço à direita é significativo.

Deixe-me te contar uma historia. Era uma vez uma usina que alimentava um incubatório de salmão próximo. O incubatório de salmão chocou um jovem salmão sem teto que embarcou em uma jornada rio acima para encontrar uma nascente. Ele encontrou essa primavera, com o nome poético "Olá, Mundo!", Onde amadureceu e gerou um novo salmão jovem. Agora os dois peixes nadavam rio abaixo, em busca do vasto oceano. Mas pouco antes da foz do rio, havia uma rede no rio - o peixe maduro foi capturado e apenas o jovem conseguiu deslizar e alcançar o oceano e o resto do universo. Enquanto isso, o incubatório havia chocado mais salmão, que também viajava rio acima e desovava e assim por diante.

No entanto, grandes quantidades de neve derretida viajavam por um braço diferente do rio. E logo após o nosso primeiro salmão jovem das nascentes de "Olá, Mundo!" atingiu o oceano, o derretimento da neve atingiu o universo e ... destruiu-o. E eles viveram felizes para sempre ... ou acho que não.

Essas eram, na verdade, a semântica do programa acima. Homespring é estranho.

Chef , 465 bytes

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.

Testado com o intérprete Ruby. Faz sopa de letrinhas.

Tentei ser o mais compatível possível com as especificações originais , mesmo que o intérprete que usei permita que você solte os thes nas Pour contentsinstruções, não o fiz.

A tigela é bem cara, então pode haver uma abordagem melhor. Tentei usar a conversão de base para codificar a mensagem, mas infelizmente a especificação não esclarece se Divideusa divisão de número inteiro ou ponto flutuante, e o intérprete que eu tenho usa a última. Também não há operador de módulo, o que também não ajuda.

Piet, 84 codéis

28x3, mostrado aqui com a largura do codel 10.

Criado com o PietDev , testado com o npiet . O layout do programa é o seguinte:

Preenchimento amarelo indica codelos onde o caminho se sobrepõe; preenchimento laranja indica codelos que devem ser da mesma cor, para fins de controle de fluxo.

Para ajudar na criação disso, escrevi um intérprete rudimentar para uma linguagem baseada em pilha com comandos semelhantes a piet, que chamei de "pasm" ( fonte ). A saída deste intérprete (com esta entrada ) é a seguinte:

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

Nenhum comando ponteiro, comutador ou rolo é usado. Também não são desperdiçados codels; de fato, dois são reutilizados.

Espaço em branco , 192 150 146 bytes

O espaço em branco precisa apenas de espaços, tabulações e linhas de alimentação enquanto outros caracteres são ignorados.
O que pode ser problemático para exibir aqui.
Portanto, no código abaixo, os espaços e tabulações foram substituídos.
E um ';' foi colocado na frente dos feeds de linha para maior clareza.
Para executar o código, primeiro substitua. e> por espaços e tabulações.

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

Hexdump do código

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

Código de montagem de espaço em branco:

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

Observações:

Eu tive que escrever um programa apenas para calcular que a adição de 107 dá o golfe ideal para a frase. Como o tamanho do bytes que um número inteiro recebe no código é alterado. : 4 + int (abs (log2 ($ n)))
O código ainda será executado sem o rótulo "e:" e a parte de saída em whitespace.kauaveel.ee . Mas isso pode tornar o código de espaço em branco inválido em outros compiladores de espaço em branco. Portanto, esses bytes não foram extraídos da solução.

Deve-se notar que

Como Kevin Cruijssen apontou nos comentários, ao permitir uma "saída por erro" conforme meta, o espaço em branco pode ter mais de 126 caracteres no código de golfe .

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

Montagem:

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!");}}

Versões anteriores do Java podem permitir que você use um bloco estático (51 bytes), mas atualmente não conheço uma maneira de ignorar o mainmétodo.

CSS, 30 bytes

:after{content:"Hello, World!"

O Cascading Style Sheets (CSS) não é uma linguagem de programação típica, mas pode produzir resultados fixos razoavelmente bem. Isso é feito criando um pseudoelemento após cada elemento com o conteúdo Hello, World!. Portanto, apenas um elemento ( <html>) é selecionado, isso pressupõe que estamos usando o documento HTML mais básico, ou seja,

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

Isso funciona na maioria dos navegadores principais, com a exceção notável do Firefox, que aplica o seletor aos elementos <html>e <body>. É também por isso que os snippets de pilha não funcionam, porque sempre há um elemento body que também é estilizado. Abaixo está uma versão ligeiramente modificada para testar.

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

HTML, 13 bytes

Hello, World!

O texto é inserido automaticamente no <body>e é exibido.

código de máquina x86_64 para Linux, 32 bytes

Quando o Linux inicia um novo processo, todos os registros (exceto o RSP) são zero, então podemos obter RAX = 1 modificando apenas o byte baixo. A ABI do System V x86-64 não garante isso, mas é o que o Linux realmente faz. Esse código funciona apenas como _startem um executável estático.

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

A instrução de chamada coloca o próximo endereço, que contém a string hello world, na pilha. Nós colocamos o endereço da string em rsi.

Em seguida, os outros argumentos são configurados para syscalla sys_write, que imprime a sequência.

O programa termina com um syscallpara sys_exit. sys_writeretorna o número de bytes gravados; portanto, os bytes superiores do RAX são zero após o primeiro syscall(a menos que retorne um erro); portanto, mov al, 60fornece RAX = __NR_exitem apenas 2 bytes.

Você pode fazer este programa segfault fechando seu stdout ( ./a.out >&-), então sys_write()retornará -EBADF, o segundo syscallretornará -ENOSYSe, em seguida, a execução cairá no final. Mas não precisamos lidar com os write()erros normalmente.

Hexagonia , 37 32 bytes

Aviso: darei uma recompensa de 500 representantes à primeira pessoa que encontrar uma solução válida em um hexágono de comprimento 3 ou uma solução comprovadamente ótima de comprimento 4. Se você não conseguir encontrar essa solução, mas conseguir vencer minha pontuação em um hexágono lateral (obtendo mais no-ops no final do programa, que podem ser omitidas no código-fonte), estou disposto a oferecer uma recompensa menor por isso também .

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

Experimente online!

Apresento orgulhosamente minha segunda linguagem de programação 2D e (que eu saiba) a primeira linguagem 2D em uma grade hexagonal.

O código fonte não parece muito 2D, parece? Bem, espaço em branco é opcional no Hexagony. Primeiro, o código fonte é preenchido com o próximo número hexagonal centralizado com no-ops ( .). O próximo número é 37, então inserimos cinco no-ops no final. Em seguida, o código fonte é reorganizado em hexágono regular:

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

Isso também é executável. Experimente online!

O Hexagony possui vários recursos bastante interessantes, incluindo 6 ponteiros de instruções diferentes e um layout de memória que é o gráfico de linhas de uma grade hexagonal, mas esse código usa apenas um IP e uma borda de memória, então não vamos nos preocupar com isso por enquanto.

Aqui está uma visão geral sobre os comandos relevantes:

• As letras apenas definem a borda da memória atual como seu valor ASCII
• ; imprime o valor atual, módulo 256, como um byte para STDOUT.
• / é um espelho que se comporta como você esperaria (causando um desvio de 120 graus no IP).
• Os dígitos funcionam como no Labirinto : multiplicam a célula atual por 10 e depois se somam.
• @ finaliza o programa.

Agora, o problema final é que a fonte envolve todos os 3 pares de arestas. Além disso, se o IP deixar a grade em um dos seis cantos, há duas linhas possíveis para as quais pular. Qual é escolhido depende se o valor atual é positivo ou não positivo. A seguinte versão anotada mostra onde o IP entra novamente sempre que sai da grade:

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

Portanto, se removermos todas as mudanças de direção, este programa se resumirá ao seguinte código linear:

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

O que é com Q2, P0e P1? As letras são impressas facilmente, pois podemos definir a borda com o valor correspondente. Para a vírgula, o espaço e o ponto de exclamação, isso não funciona. Nós também não pode apenas definir o seu valor com 44, 32, 33, respectivamente, porque a borda de memória é diferente de zero para começar, e devido à semântica de dígitos individuais que iria causar todos os tipos de estragos. Se quiséssemos fazer isso, teríamos de redefinir o valor borda a zero com algo como *, +, -, &ou ^em primeiro lugar. No entanto, como o valor é obtido no módulo 256 antes de ser impresso, não precisamos definir os valores exatamente como 44, 32 ou 33. Por exemplo, Q2definiremos o valor da borda como 81*10 + 2 = 812, que é44quando tomado módulo256. Dessa forma, podemos salvar um byte em cada um desses três caracteres. (Infelizmente, nunca é possível chegar lá com um único dígito a partir do valor da célula já. Amusingly, onde ele faz o trabalho é o ode World, porque isso pode também ser obtido a partir W9.)

Você pode usar esse script CJam para encontrar todas as combinações de dígitos de letras que resultam em um determinado caractere.

Não tenho certeza se isso é ideal. Duvido que seja possível fazê-lo em um hexágono de comprimento lateral 3 (onde você teria apenas 19 caracteres disponíveis), mas talvez seja possível resolvê-lo em um hexágono com comprimento lateral 4 com menos de 32 comandos, como que existem mais no-ops no final da grade.

Malbolge, 112 bytes

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

Vou ver se há um mais curto. Tenho um computador melhor desde a última vez, para que eu possa gerar um pouco mais rápido.

Para o show, aqui está "Olá, mundo!" sem a vírgula.

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

Fourier , 15 bytes

GRANDES MUDANÇAS para Fourier!

`Hello, World!`

Experimente no FourIDE!

Sim, os dias de digitação do código ASCII de cada caractere se foram para sempre: Fourier agora suporta seqüências de caracteres. Quando você coloca uma string nos backticks, essa string é emitida.

Observe que você não pode fazer outra coisa senão produzir essa sequência: você não pode armazená-la em uma variável, ela não é armazenada no acumulador e não existem ferramentas de manipulação de sequência.

Aqui, você pode encontrar o acidente de trem que era velho Fourier. ;)

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

Experimente online!

Agora, alguns de vocês provavelmente já conheceram Fourier e podem estar bastante familiarizados com o idioma. Toda a linguagem é baseada em um acumulador: uma variável global que praticamente todos os operadores usam.

A parte mais importante do código é o aoperador. Isso pega o valor numérico do acumulador e o converte em um caractere usando o código Python chr(accumulator). Isso é impresso em STDOUT.

Infelizmente, ainda não tive a chance de usar Fourier ( nudge nudge , wink wink ), principalmente devido à falta de strings e operadores de strings. Mesmo assim, ainda é utilizável para muitos outros desafios (consulte a seção de exemplos da página EsoLangs).

Observe que isso é mais curto que minha entrada na lista Esolangs porque eu realmente não achava que poderia jogar mais. E então, ao escrever o desafio do golfe por cordas de Fourier, percebi que poderia diminuir um pouco.

Nota

Se você estava pensando sobre a sintaxe da variável, o Geobits escreveu um programa que usa variáveis e tem o mesmo comprimento:

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

Experimente online!

C-- , 155 bytes

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);}

Infelizmente, o único compilador C - conhecido, o Quick C - não é mais mantido. É uma dor no pescoço construir, mas é possível ...

C, 30 bytes

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

Bastante baunilha, mas não consigo pensar em uma maneira comum de ser compilável para fazê-lo mais curto (a menos que talvez algum tipo de truque cru de asm possa funcionar?). Ainda assim, supera a maioria dos esolangs!

Ilegível , 843 755 732 666 645 629 577 bytes

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

Os programas ilegíveis devem ser exibidos com uma fonte de largura variável, para que honrem o nome do idioma. Estou um pouco decepcionado que minhas abordagens mais sofisticadas acabaram sendo muito mais longas. Loops são incrivelmente caros em Ilegível ...

Experimente online!

Como funciona

Ilegível tem apenas dez funções; seis deles são usados ​​neste código:

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

Depois de usar minha notação de caractere único e adicionar alguns espaços em branco e comentários, o código acima se parece com o seguinte. Instruções de várias linhas são executadas de baixo para cima.

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 (!).

Eu gerei o código fonte real executando a versão não comentada do pseudocódigo acima através deste programa CJam .

Befunge 98 , 19 18 bytes

Nova resposta (de undergroundmonorail)

"ck,@!dlroW ,olleH

Explicação

• " inicia o modo de sequência
• Tudo o que se segue é enviado para a pilha. A pilha está agoraHello, World!@,kc
• Depois de chegar ao final, o intérprete volta ao início
• Ele encontra "novamente, encerrando o modo de sequência
• 12 é empurrado para a pilha ( c)
• k pega o valor máximo da pilha e executa o próximo comando que o ponteiro da instrução pode ver que muitas vezes
• ,exibe um valor da pilha e o gera como um caractere. Foi executado 12 vezes pela última kinstrução e mais uma vez quando o intérprete realmente lê a ,instrução
• @ termina o programa

A diferença com a resposta antiga é que reutilizamos o "personagem de maneira inteligente , usando o comportamento de loop do Befunge quando ele atinge o final da linha. Como pode ser menos intuitivo, também deixo o antigo. Além disso, você deve ter notado que a pilha ainda contém alguns caracteres (ck,@ ) por causa desse truque, deixando alguma bagunça se quisermos fazer algo depois disso.

Resposta antiga

"!dlroW ,olleH"ck,@

Isso funciona para funge e befunge 98

Explicação

• Tudo entre ""é empurrado para a pilha. ( 'H'agora está no topo.)
• c (12) é empurrado para a pilha
• k pega o valor máximo da pilha e executa o próximo comando que o ponteiro da instrução pode ver isso várias vezes.
• ,exibe um valor da pilha e o gera como um caractere. Ele foi executado 12 vezes pela última kinstrução e mais uma vez quando o intérprete realmente lê o,instrução
• @ termina o programa

JSFuck , 6293 6289 6277 bytes

Isso pode ser mencionado como um dos mais longos "programas mais curtos do Hello, World! " (Na verdade, eu não sei se isso é ideal, mas é o mais curto que consegui).

Aviso: só funciona no Firefox e Safari

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

Também há uma versão um pouco mais longa (+4 bytes) que também funciona no Chrome e no Microsoft Edge:

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

Para aqueles que não estão familiarizados com o JSFuck, trata-se de escrever JavaScript como se houvesse apenas seis caracteres, e isso pode ficar bem louco às vezes.

Esta tabela mostra como os caracteres usados ​​no Hello, World! programa são codificados no JSFuck. O código de texto simples é justo 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                 |
+----------+--------------------------------------+---------------------------+

Aqui, as cadeias "fill", "fontcolor"etc. devem ser escritas como "f"+"i"+"l"+"l", "f"+"o"+"n"+"t"+"c"+"o"+"l"+"o"+"r"para serem codificadas.

Os identificadores globais self, atobe btoasão escritos como Function("return self")().

Functionem si deveria ser []["fill"]["constructor"].

A vírgula ","é complicada, não tenho 100% de certeza de como funciona, mas usa a []["concat"]função para criar uma matriz. Vou postar uma atualização quando tiver tempo para fazer mais testes.

Eu codifiquei isso usando JScrewIt - créditos no GOTO 0 por criar uma ferramenta tão sofisticada:

• Abra o Firefox (você pode escolher qualquer outro navegador (s), mas o código apenas do Firefox é o mais curto.)
• Navegue para JScrewIt : http://jscrew.it
• Entrada: alert("Hello, World!")
• Código executável: marcado
• Compatibilidade: Somente este navegador

Isso difere da minha resposta a esta pergunta pela presença de vírgula após "Olá".

Curiosamente, a sintaxe do ES6

alert`Hello, World!`

leva ainda mais bytes para codificar (+1500 ou mais) devido à maior complexidade de codificar dois backticks em vez de ("e ").

Pada , 83 68 bytes

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

Eu acredito que isso é ideal para um programa linear (ou seja, um que não use os operadores de fluxo de controle ?e *). Pode ser ideal no geral, mas não sei como usar esses operadores adicionais em uma quantidade tão pequena de código (ou como explorar as possibilidades programaticamente).

O idioma passou recentemente por algumas alterações depois que comecei a discuti-lo com o autor por email. No entanto, eu escrevi uma implementação de referência para o estado atual da especificação de idioma na semana passada, portanto, o código acima é realmente executável.

Metagolf

Originalmente, eu havia usado o resultado da minha implementação de referência para esse desafio e criado uma solução artesanal com base nisso. No entanto, essa foi apenas uma abordagem heurística.

Então, em vez disso, escrevi um solucionador no Mathematica que realmente conhece as estruturas de dados e os operadores do Pada para encontrar uma solução ideal. Em média, cresce linearmente com o comprimento da string (embora algumas combinações de caracteres sejam um pouco mais lentas que outras) e demorou cerca de 1,5 horas Hello, World!.

Então, como eu escrevi o solucionador? Primeiro, percebemos que precisamos considerar apenas 6 operadores: ~.oOqQ(mais o necessário wpara cada um dos caracteres impressos). Usar as pilhas ou os bloqueios de bits não é útil no código linear, e eu não acredito nisso ?e* pode ser usado efetivamente em menos de 68 bytes.

O estado de Pada (ignorando as pilhas e bloqueios) consiste em 7 switches e 8 bits, organizados da seguinte maneira:

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

Então, isso é possível estados. Minha primeira etapa de pré-processamento foi configurar um gráfico direcionado de estados em que cada extremidade corresponde a uma única operação. Ou seja, o gráfico possui 32768 vértices, cada um com grau externo 6 (uma borda de saída para cada uma das 6 operações consideradas). Podemos usar este gráfico para encontrar o caminho mais curto entre dois estados (este gráfico por si só pode ser bastante útil para jogar golfe no Pada).215 = 32768

Agora, para cada personagem, queremos alcançar um estado em wque esse personagem seja impresso. Quantos estados existem? wlê o byte do bit em que é descartado (ciclicamente). Portanto, existem 8 rotações possíveis dos bits do caractere que podem imprimir esse caractere. Para cada uma dessas rotações, três interruptores são fixos (para fazer a wqueda na posição correta). Isso deixa 4 opções arbitrárias. Portanto, temos estados possíveis para cada um em nosso código.8 * 24 = 128w

Com eles, podemos resolver outro problema de gráfico: construa um gráfico que tenha um vértice de origem, depois uma "camada" para cada caractere e um vértice de afundamento. As camadas consistem nos 128 estados de cada vértice, o nó de origem corresponde ao estado inicial do programa (todas as opções à esquerda e todos os bits são zero). O nó coletor não corresponde a nenhum estado em particular. Temos arestas direcionadas de todos os vértices em uma camada para todos os vértices na próxima camada, onde o peso da aresta é a distância entre os dois estados em nosso gráfico anterior. Os pesos das arestas da última camada até a pia são todos 0. Ou seja, podemos pré-calcular todos esses pesos. Essa é a etapa mais cara da computação e levou 1,5 horas para Hello, World!.

Com esse gráfico configurado, podemos encontrar o caminho mais curto da fonte até o coletor rapidamente (foram necessários 0,05s na minha máquina). Para Hello, World!os estados desejados são:

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

onde os 7 bits menos significativos correspondem aos comutadores e os 8 bits mais significativos aos bits de Pada.

Agora voltamos ao primeiro gráfico e encontramos as arestas reais (ou seja, operações) correspondentes ao caminho mais curto entre cada par de estados subsequentes e terminamos cada um deles com a w. Voilà, uma solução ideal (com base nas premissas acima).

Aqui está o Mathematica completo, se alguém quiser metagolfar uma string diferente no 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]) <> ""