Entonces ... eh ... esto es un poco embarazoso. Pero no tenemos un simple "¡Hola, mundo!" desafío aún (a pesar de tener 35 variantes etiquetadas con hello-world y contando). Si bien este no es el código de golf más interesante en los idiomas comunes, encontrar la solución más corta en ciertos esolangs puede ser un desafío serio. Por ejemplo, que yo sepa, aún no se sabe si se ha encontrado la solución Brainfuck más corta posible.

Además, si bien toda Wikipedia (la entrada de Wikipedia se ha eliminado pero hay una copia en archive.org ), esolangs y Rosetta Code tienen listas de "¡Hola, Mundo!" programas, ninguno de estos está interesado en tener el más corto para cada idioma (también existe este repositorio de GitHub ). Si queremos ser un sitio importante en la comunidad de golf de código, creo que deberíamos intentar crear el catálogo definitivo del más corto "¡Hola, Mundo!" programas (similar a cómo nuestro desafío básico de quine contiene algunos de los quines más cortos conocidos en varios idiomas). ¡Entonces hagamos esto!

Las normas

• Cada presentación debe ser un programa completo.
• El programa no debe ingresar nada e imprimir Hello, World!en STDOUT (este flujo de bytes exacto, incluyendo mayúsculas y puntuación) más una nueva línea final opcional, y nada más.
• El programa no debe escribir nada en STDERR.

• Si alguien quiere abusar de esto creando un lenguaje donde se imprima el programa vacío Hello, World!, luego felicidades, simplemente allanaron el camino para una respuesta muy aburrida.

  Tenga en cuenta que debe haber un intérprete para que se pueda probar el envío. Se permite (e incluso se recomienda) escribir este intérprete usted mismo para un idioma previamente no implementado.

• Las presentaciones se puntúan en bytes , en una codificación apropiada (preexistente), generalmente (pero no necesariamente) UTF-8. Algunos idiomas, como las carpetas , son un poco difíciles de puntuar; si tiene dudas, pregunte por Meta .
• No se trata de encontrar el idioma con el más corto "¡Hola, mundo!" programa. Se trata de encontrar el más corto "¡Hola, mundo!" programa en todos los idiomas. Por lo tanto, no marcaré ninguna respuesta como "aceptada".
• Si su idioma de elección es una variante trivial de otro lenguaje (potencialmente más popular) que ya tiene una respuesta (piense en dialectos BASIC o SQL, shells Unix o derivados triviales de Brainfuck como Alphuck), considere agregar una nota a la respuesta existente que el La misma solución o una muy similar también es la más corta en el otro idioma.

Como nota al margen, no desestime las respuestas aburridas (pero válidas) en idiomas en los que no hay mucho para jugar al golf; estas siguen siendo útiles para esta pregunta, ya que trata de compilar un catálogo lo más completo posible. Sin embargo, hacer respuestas principalmente Upvote en los idiomas en que los autores hecho, tuvimos que poner esfuerzo en el código de golf.

Para inspirarte, mira la colección Hello World .

El catálogo

El Fragmento de pila al final de esta publicación genera el catálogo a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento:

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

Atascado, 0 bytes

Bueno, no puede ser más corto que eso ... Un programa vacío saldrá Hello, World!en Stuck .

PHP, 13 bytes

Hello, World!

Si. Funciona.

Brainfuck, 78 bytes

Recompensa abierta: si alguien puede mejorar esta puntuación, les pasaré la recompensa (+500). ¡@KSabha encontrado unasolución de 76 72 bytes!

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

Pruébalo en línea!

Los primeros 28 bytes --<-<<+[+[<+>--->->->-<<<]>]inicializan la cinta con la siguiente relación de recurrencia (mod 256):

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

El factor de 171 surge porque 3 ^-1 ≡ 171 (mod 256) . Cuando el valor actual se traduce una celda hacia atrás (vía <+>---), restando 3 cada vez multiplica efectivamente el valor por 171.

En n = 220, el valor a traducir es cero, y la iteración se detiene. Los diez bytes que preceden al punto de detención son los siguientes:

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

Contiene todos los componentes necesarios para producir Hello, World!, en forma de caza y picoteo, con pequeños ajustes.

También he encontrado una solución alternativa de 78 bytes:

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

Pruébalo en línea!

Considero que este es mejor que el primero por varias razones: usa menos celdas que quedan en casa, modifica menos celdas en total y termina más rápidamente.

Mas detalle

Las relaciones de recurrencia tienen representaciones sorprendentemente concisas en Brainfuck. El diseño general es el siguiente:

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

que representa:

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

Además, <+>se puede cambiar para multiplicar el rango por una constante sin afectar el punto de parada, y se puede agregar un término antes >{k}de cambiar el rango por una constante, nuevamente sin afectar el punto de parada.

Otros ejemplos

Secuencia Fibonacci

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

Números N-gonales

Números triangulares

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

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

Números cuadrados

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

Números Pentagonales

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

etc.

BF Crunch

He publicado el código que usé para encontrar algunas de estas soluciones en github . Requiere .NET 4.0 o 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.

La salida se da en tres líneas:

1. Duración total del programa encontrado y el segmento de inicialización.
2. Ruta tomada, comenzando con el puntero de cinta actual. Cada nodo corresponde a un carácter de salida, representado como (puntero, costo).
3. Segmento de cinta utilizado.

Por ejemplo, el resultado final para bfcrunch "hello world" 70 -r -i23es:

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

Esto corresponde al programa completo:

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

Otros registros

¡Hola Mundo!

Envoltura, 78 bytes :

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

o

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

Sin envoltura, 87 bytes (anteriormente 92 bytes (mitchs) ):

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

¡Hola Mundo!

Envoltura, 80 bytes :

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

Sin envoltura, 81 bytes (anteriormente 92 bytes (hirose) ):

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

¡Hola Mundo!

Envoltura, 74 bytes :

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

Sin envoltura, 84 bytes :

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

Versión de Esolangs

Hola mundo! \ N

Envoltura, 76 bytes :

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

Esto usa una celda a la izquierda del hogar, y por lo tanto se consideraría 77.

Sin envoltura, 83 bytes :

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

Rdebath aprobado . salida de 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)

Hola Mundo!

Envoltura, 70 bytes (anteriormente 78 ¹ ):

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

Sin envoltura, 77 bytes (¿anteriormente 89?):

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

El autor afirma que el más corto "Hello World!" Codificado a mano tiene 89 bytes, pero no proporciona referencia. Por la presente también reclamo el registro de esto.

¡Hola Mundo!

Envoltura, 65 bytes (anteriormente 66 bytes):

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

En realidad, esto también está codificado a mano (lo mejor que pude encontrar al procesar es de 68 bytes ). La primera celda se inicializa a 259 (3), y se decrementa en 7 cada iteración, haciendo un ciclo 37 veces. La siguiente celda se reduce en 6, lo que resulta en 256 - 6 · 37 = 34 . El resto de las celdas se reducen en 4 cada vez, agregando una celda cada iteración, con cada celda nueva inicializada a 252 (-4). El resultado es el siguiente:

[  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 solución dada (79 bytes) se puede reducir trivialmente en uno:

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

ArnoldC , 71 bytes

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

Solo para lols ..

Semilla , 6016 4234 4203 bytes

20 854872453003476740699221564322673731945828554947586276010721089172712854441839676581917455319274850944955030258951339804246125714958815519550291630078076933441706558540342671975808828643360922071900333028778314875248417953197990571991784126564752005357199892690656368640420204822142316716413192024742766282266114842280731756458212469988291309261528542889299297601723286769284159107438930448971911102280330101196758384815655479640836157495863547199726234352265518586460633795171196315255736880028338460236768181141732764911402112878175632130129852788301009582463631290071329795384336617491655825493435803011947670180368458659271192428341035912236946048939139042310380278430049252171822721598175984923434205610723412240162418996808671543770639111617709604242882388664919702606792443015941265168129550718541372361144081848761690730764968771245566074501485020726368378675085908872608679630368472956274468410052703615106090238423979678950131481176272880569100533049143775921798055136871254424261001442543122666701145111965968366507060931708140304772342855064834334129143038575569044150428480231956133612367393837580345180691911525531699573096952433882387811884727975431823620782822755161559988205401134640722220804177812794328129589949692446031008866917615922944976151073653201316255518389496411696741029209242119521978920200314572718584995265523235225587228975886710511855501710470163649632761488899317729943053884132314641377747687975638119132094777769497069556255954031537245957811105217875011509899497752696062748928963281605780942517262774976217663461063680912331030221981433051827519906741285738915397005702326447635845195923640649166530310494885569783989508000344280715868581532826832242144647203531393142251025361866506821695860883605004105862208004440476654027574832078603305884731766236740069411566854496824754558761536201352147934963241039597221404341132342297870517293237489233057335406510464277610336142382379135365550299895416613763920950687921780736585299310706573253951966294045814905727514141733220565108490291792987304210662448111170752411153136765318541264632854767660676223663544921028492602135525959428999005153729028491208277493747933069008199074925710651071766675870081314909460661981433426167330215548196538791617762566403934129026219366764038390123622134753742930729751695349588862441999672547791630729398908283091638866715502470152431589429837867944760012419885615525232399584379209285060418518373512154801760060312646951597932345591416241634668119867158079946680321131213357200382937049485606706114467095019612014749723443159443363662563254359712162432143334612180576945072905749883870150120687696027984317320305291407322779803583395375616762530641605634303022155218169343410634115050596030685041633824154135240376022159918501703555881290333205131375705406831260759974112248490451605422031345264183102048614606636275942039438138959188478277971377232005036301145411215067576576667743288951344423152531417111852584846747428443123174595987315325304540564683047858415059703724263652136185848573853965992798725654430360647040362341567082462847275277303225817689141675391972818943419663764371222973269129542760661385278009266471167618553065823580448848795731295589715602705860758954890415040763604082216728159486423396295188510311881004469017351709060492844398219491990895826924575575549615118821417543037296628825303328056839433114519945243963946989899508355224823109677424196639930153649890175062456649384605721510239142861693109687536600667811037619175927995599388547421689316110236566026931360164495251160997857372500940728057700473763884480342708897319990346726967220426504612260565552531158509215849649565188655100774748485416791517853427613458459889062942881409801879085054494129489535044719193283409051007851153504224002807392992520076910314763705776345053922387355156981872691537772657428096384535960466923475731297217863371650154415835785630016335858514130863258775100537612371430357576913148500310344278511588325852376442503898849856566716198848377379400158332792027967216204970114516984638014129252882482309132898416484525230488700253065644547798869056136044415413099076332059572505138116227535024546891015836838323022822272664771489129085797354578016574544759934333471793

El programa Befunge-98 resultante (basado en esto ) es

"9!dlroW ,olleH"ck,@

Mornington Crescent , 3614 3568 bytes

Gracias a NieDzejkob por guardar 46 bytes usando nombres de línea más cortos.

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

Pruébalo en línea!

Esto es ciertamente subóptimo, pero es la mitad del tamaño de la solución en esolangs.

Hello, World se construye cortando los siguientes nombres de estaciones y concatenando los resultados:

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

Finalmente, estoy calculando el código de caracteres de !as (2<<4)+1 == 33. Todas estas partes se concatenan en Paddington y finalmente se imprimen en Mornington Crescent.

Nota: El idioma no especifica si es posible viajar a la misma estación dos veces seguidas, pero el intérprete lo permite, así que lo he utilizado.

mal , 70 bytes

aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

Utiliza los siguientes cuatro comandos:

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

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

Pruébalo en línea!

Y la solución original de 76 bytes sin envoltura :

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

Pruébalo en línea!

Otras soluciones más cortas conocidas (que yo sepa) que he encontrado

'¡Hola Mundo!' 77 bytes:

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

Pruébalo en línea!

'¡Hola Mundo!' 70 bytes:

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

Pruébalo en línea!

Estos se encontraron usando un programa de C ++ que escribí aquí: https://github.com/ksabry/bfbrute

Nota: Originalmente quería limpiar este código antes de publicarlo para que sea realmente legible y utilizable, pero como no lo he hecho en más de un año, creo que lo publicaré tal como está. Hace un uso intensivo de plantillas y constantes de tiempo de compilación para cualquier optimización potencial y tiene un montón de código comentado de mis pruebas, pero no hay comentarios útiles, lo siento, pero es un poco horrible.

No hay nada terriblemente inteligente sobre el código, es su fuerza bruta en su núcleo, sin embargo, está bastante optimizado. La optimización principal es que primero itera a través de todos los programas sin bucles (no [o ]) hasta una longitud especificada (16 actualmente) y almacena en caché una matriz de todos los cambios que realizará en la matriz de datos. Es sólo almacenará un solo programa por matriz única de cambios así que por ejemplo sólo una de >+<<->y <->>+<será almacenado. Luego itera a través de todos los programas posibles que se componen de cualquier programa en este caché con cualquier combinación de bucles entre ellos. Después de ejecutar cada programa, realiza una simple búsqueda codiciosa y picotea a los personajes y los agrega al final del programa.

Después de ejecutar esto a través del espacio de todos los programas, noté que casi todos los programas más cortos (de hasta ~ 19) tenían la forma *[*[*]*]. Restringir la búsqueda a programas de esta forma aceleró la búsqueda considerablemente. El poseedor del registro actual se encontró en la longitud 27. En realidad, se calculó que tenía una longitud 74, pero noté una secuencia particular .>.>.>.que tuvo la suerte de tener un 0 en la celda de datos a la derecha, lo que permite simplificarlo para [.>]<reducirlo. a 72.

Lo dejé correr por bastante tiempo y completé la búsqueda con los parámetros actuales hasta 29, sospecho que será difícil superar el actual simplemente yendo más alto, creo que el enfoque más prometedor probablemente sería aumentar el espacio de búsqueda en De alguna manera inteligente.

Piet, 90 codeles

Esta es una imagen de 30 por 3. Alternativamente, en el tamaño de codel 10:

Utiliza un diseño de 3 alturas, por lo que solo necesito apuntar una vez. Si esto todavía es golfable, probablemente podría afeitarme como máximo en otra columna, ya que hay un no-op de push-pop allí.

Editar: la solución 84 codel de @primo .

Alpaca , 17 bytes

Haystack es un lenguaje de programación 2D que se ejecuta hasta que encuentra la aguja en el pajar |, todo mientras realiza operaciones basadas en la pila. Todos los programas comienzan desde la esquina superior izquierda y pueden usar los caracteres direccionales><^v para moverse por el programa. La dirección se hereda, por lo que no necesita seguir usando >para ir a la derecha, la dirección solo cambiará cuando toque un carácter direccional diferente.

Por defecto, el intérprete lee desde la parte superior izquierda hacia la derecha, por lo que podemos simplemente decir "¡Hola, mundo!" sobre la pila, use opara imprimirla, luego coloque la aguja para terminar de ejecutar.

"Hello, World!"o|

Bonus: una versión más emocionante:

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

Ayuda, WarDoq! , 1 byte

H

¡ Ayuda no solo ayuda, WarDoq! tiene una función integrada para la ortografía más común de la frase, incluso satisface nuestra definición habitual de lenguaje de programación.

Pruébelo en el intérprete oficial en línea (el código va en Entrada ).

MarioLANG , 259 249 242 240 235 bytes

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

Esto ha sido probado en la implementación de Ruby .

Después de ofuscar "¡Hola, mundo!"en MarioLANG lo estudié un poco. Lo anterior es el más corto que he encontrado hasta ahora.

Como antes, comencé con una solución Brainfuck que establece cuatro celdas al múltiplo de 10 más cercano a los caracteres He,y el espacio y lo convirtió a MarioLANG . Luego puede acortar un poco el código haciendo uso del piso auxiliar en el bucle que casi reduce a la mitad el ancho del bucle. Tenga en cuenta que la parte inferior solo se ejecuta una vez menos que la parte superior, por lo que ya no obtiene múltiplos exactos del contador inicial en las 4 celdas.

Finalmente, quería aprovechar el espacio desperdiciado en frente del circuito, así que agregué un montón de ascensores para aprovechar el espacio vertical allí. Y luego me di cuenta de que podía doblar el código después del bucle (ver la revisión anterior) debajo del bucle para utilizar un poco más de espacio vertical, lo que ahorró cinco bytes más.

Es probable que esto todavía esté lejos de ser perfecto, pero creo que es una mejora decente sobre la solución ingenua.

Metagolf

Tiempo para algo de automatización ...

He comenzado a configurar un solucionador en Mathematica para encontrar una solución óptima. Actualmente se supone que la estructura del código es fija: el contador se establece en 12, 4 celdas para imprimir, con la asignación fija He,<space>y el mismo orden de esas celdas. Lo que varía es el número de +s en el bucle, así como las correcciones necesarias después:

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
 ]

Resulta que para un contador inicial de 12 mi solución artesanal ya es óptima. Sin embargo, el uso de 11 ahorra dos bytes. Intenté todos los valores de contador del 6 al 20 (inclusive) con los siguientes 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 supone que el código lineal después del bucle está en la línea superior, y el código anterior es esa solución plegada. Puede haber una solución general más corta haciendo que el solucionador sea consciente del plegado, porque ahora obtengo 3 +s más en la primera parte de forma gratuita, y las siguientes 4 instrucciones costarían solo 1 byte en lugar de 2.

Oscuro , 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

Solo dejaré que algunas citas de la especificación del idioma hablen de la brillantez de este esolang:

Dark es un lenguaje basado en la manipulación de mundos y dimensiones enteros para lograr objetivos y construir la mejor realidad tortuosa posible.

Cada vez que ocurre un error de sintaxis, la cordura del programa disminuye en 1. [...] Si la cordura del programa llega a cero, el intérprete se vuelve loco.

La corrupción voltea un solo bit en la variable cuando ocurre.

Cuando el maestro muere, todas las variables de servicio adjuntas a ese maestro también mueren. Esto es útil para agrupar y matar en masa variables.

Obliga a una variable a suicidarse, liberándola (recuerde que dejará decadencia).

Establece una variable en un valor aleatorio. Utiliza el generador de caos global.

Si no se inicializa un acosador, cualquier intento de realizar IO dará como resultado que se escriban mensajes de error deprimentes en la consola.

Homespring , 58 bytes

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

El espacio final es significativo.

Dejame contarte una historia. Había una vez una planta de energía que alimentaba un criadero de salmón cercano. El criadero de salmones incubó un salmón joven sin hogar que se embarcó en un viaje río arriba para encontrar un manantial. Encontró tal manantial, con el nombre poético "¡Hola, Mundo!", Donde maduró y generó un nuevo salmón joven. Ambos peces ahora nadaban río abajo, en busca del amplio océano. Pero justo antes de la desembocadura del río, había una red en el río: el pez maduro fue capturado y solo el joven logró deslizarse y llegar al océano y al resto del universo. Mientras tanto, la planta de incubación había eclosionado más salmón que también había viajado río arriba y engendrado, y así sucesivamente.

Sin embargo, grandes cantidades de nieve derretida habían estado viajando por un brazo diferente del río. Y justo después de nuestro primer salmón joven de los manantiales de "¡Hola, mundo!" ha llegado al océano, el deshielo golpeó el universo y ... eh ... lo destruyó. Y vivieron felices para siempre ... o supongo que no.

Esos fueron en realidad la semántica del programa anterior. Homespring es raro.

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.

Probado con el intérprete de Ruby. Hace sopa de letras.

Traté de cumplir con la especificación original como pude, por lo que, aunque el intérprete que utilicé te permite dejar caer el thes en elPour contents instrucción, no lo he hecho.

El tazón para mezclar es bastante caro, por lo que podría haber un mejor enfoque. Intenté usar la conversión de base para codificar el mensaje, pero desafortunadamente la especificación no aclara si Divideusa división entera o de coma flotante, y el intérprete que tengo usa la última. Tampoco hay un operador de módulo, que tampoco ayuda.

Piet, 84 codeles

28x3, aquí se muestra con el ancho de codel 10.

Creado con PietDev , probado con npiet . El diseño del programa es el siguiente:

El relleno amarillo indica los codeles donde el camino se superpone, el relleno naranja indica los codels que deben ser del mismo color, para propósitos de control de flujo.

Para ayudar en la creación de esto, escribí un intérprete rudimentario para un lenguaje basado en pila con comandos tipo piet, que he denominado "pasm" ( fuente ). La salida de este intérprete (con esta entrada ) es la siguiente:

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

No se utilizan punteros, interruptores ni comandos de desplazamiento. Tampoco se desperdician los códeles; de hecho dos son reutilizados.

Espacio en blanco , 192 150 146 bytes

El espacio en blanco solo necesita espacios, pestañas y saltos de línea, mientras que otros caracteres se ignoran.
Lo cual puede ser problemático para mostrar aquí.
Entonces, en el código debajo de los espacios y pestañas fueron reemplazados.
Y un ';' se colocó delante de los avances de línea para mayor claridad.
Para ejecutar el código, primero reemplace. y> por espacios y tabulaciones.

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

Hexdump de 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 ensamblaje de espacios en blanco:

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

Observaciones:

Tuve que escribir un programa solo para calcular que sumar 107 da el golf óptimo para la oración. Dado que el tamaño de bytes que toma un entero en el código cambia. : 4 + int (abs (log2 ($ n)))
El código aún se ejecutará sin la etiqueta "e:" y la parte de salida en whitespace.kauaveel.ee . Pero eso podría invalidar el código de espacio en blanco en otros compiladores de espacio en blanco. Así que esos bytes no fueron extraídos de la solución.

Se debe notar que

Como Kevin Cruijssen señaló en los comentarios, al permitir una "salida por error" según el meta, el espacio en blanco se puede codificar con más de 126 caracteres.

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

Montaje:

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

Las versiones anteriores de Java pueden permitirle usar un bloque estático (51 bytes), pero actualmente no conozco una forma de evitar el mainmétodo.

CSS, 30 bytes

:after{content:"Hello, World!"

Las hojas de estilo en cascada (CSS) no son un lenguaje de programación típico, pero pueden generar resultados fijos bastante bien. Esto se hace creando un pseudo-elemento después de cada elemento con el contenido Hello, World!. Entonces, solo <html>se selecciona un elemento ( ), esto supone que estamos usando el documento HTML más básico, es decir

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

Esto funciona en la mayoría de los principales navegadores, con la notable excepción de Firefox, que aplica el selector a los elementos <html>y <body>. Esta es también la razón por la cual los fragmentos de pila no funcionan, porque siempre hay un elemento del cuerpo que también se estiliza. A continuación se muestra una versión ligeramente modificada para probar.

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

HTML, 13 bytes

Hello, World!

El texto se inserta automáticamente en <body>, y se muestra.

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

Cuando Linux inicia un nuevo proceso, todos los registros (excepto RSP) son cero, por lo que podemos obtener RAX = 1 solo modificando el byte bajo. El x86-64 System V ABI no garantiza esto, pero es lo que Linux realmente hace. Este código solo funciona como _starten un ejecutable 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

La instrucción de llamada empuja la siguiente dirección, que contiene la cadena hello world, en la pila. Introducimos la dirección de la cadena rsi.

Luego, los otros argumentos se configuran para un syscallto sys_write, que imprime la cadena.

El programa termina con un syscallto sys_exit. sys_writedevuelve el número de bytes escritos, por lo que los bytes superiores de RAX son cero después del primero syscall(a menos que haya devuelto un error), entonces mov al, 60nos da RAX =__NR_exit en solo 2 bytes.

Puede hacer que este programa sea predeterminado al cerrar su stdout ( ./a.out >&-), por sys_write()lo que regresará -EBADF, el segundo syscallregresará -ENOSYSy luego la ejecución se caerá al final. Pero no necesitamos manejar los write()errores con gracia.

Hexagonía , 37 32 bytes

Aviso: le daré una recompensa de 500 repeticiones a la primera persona que encuentre una solución válida en un hexágono de longitud lateral 3 o una solución demostrablemente óptima de longitud lateral 4. Si no puede encontrar esa solución, pero logro superar mi puntaje en un hexágono 4 de longitud lateral (al obtener más no-ops al final del programa, que se puede omitir del código fuente), estoy dispuesto a dar una recompensa más pequeña por eso también .

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

Pruébalo en línea!

Presento con orgullo mi segundo lenguaje de programación 2D y (que yo sepa) el primer lenguaje 2D en una cuadrícula hexagonal.

El código fuente no se ve muy 2D, ¿verdad? Bueno, el espacio en blanco es opcional en Hexagony. Primero, el código fuente se rellena al siguiente número hexagonal centrado con no-ops ( .). El siguiente número es 37, por lo que insertamos cinco no-ops al final. Luego, el código fuente se reorganiza en un hexágono regular:

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

Esto también es ejecutable. Pruébalo en línea!

Hexagony tiene un montón de características bastante originales, que incluyen 6 punteros de instrucciones diferentes y un diseño de memoria que es el gráfico lineal de una cuadrícula hexagonal, pero este código usa solo una IP y un borde de memoria, así que no nos preocupemos por eso por ahora.

Aquí hay una descripción general de los comandos relevantes:

• Las letras solo establecen el borde de la memoria actual a su valor ASCII
• ; imprime el valor actual, módulo 256, como un byte a STDOUT.
• / es un espejo que se comporta como cabría esperar (haciendo que la IP tome un giro de 120 grados).
• Los dígitos funcionan como lo hacen en Labyrinth : multiplican la celda actual por 10 y luego se suman.
• @ termina el programa

Ahora la captura final es que la fuente se envuelve alrededor de los 3 pares de bordes. Además, si la IP sale de la cuadrícula a través de una de las seis esquinas, hay dos filas posibles para saltar. El que se elija depende de si el valor actual es positivo o no positivo. La siguiente versión anotada muestra dónde vuelve a ingresar la IP cada vez que sale de la cuadrícula:

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

Entonces, si eliminamos todos los cambios de dirección, este programa se reduce al siguiente código lineal:

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

¿Qué pasa con Q2, P0y P1? Las letras se imprimen fácilmente porque podemos establecer el borde en el valor correspondiente. Para la coma, el espacio y el signo de exclamación, eso no funciona. Asimismo, no podemos simplemente establecemos su valor con 44, 32, 33, respectivamente, debido a que el borde de memoria no es cero, para empezar, y debido a la semántica de los dígitos individuales que causaría todo tipo de estragos. Si quisiéramos hacer eso, tendríamos que restablecer el valor de borde a cero con algo como *, +, -, &o ^en primer lugar. Sin embargo, dado que el valor se toma el módulo 256 antes de imprimirse, no tenemos que establecer los valores exactamente en 44, 32 o 33. Por ejemplo,Q2 estableceremos el valor de borde cuando se tome el módulo81*10 + 2 = 812 , que es44256. De esta manera podemos guardar un byte en cada uno de esos tres caracteres. (Por desgracia, nunca es posible llegar con un solo dígito del valor de la celda ya ha. Sorprendentemente, donde se hace el trabajo es la ode World, porque eso también puede ser obtenido a partir de W9.)

Puede usar este script CJam para encontrar todas las combinaciones de letras y dígitos que den como resultado un carácter dado.

No estoy seguro de si esto es óptimo. Dudo que sea posible hacerlo en un hexágono de longitud lateral 3 (donde solo tendría 19 caracteres disponibles), pero podría ser posible resolverlo en un hexágono con longitud lateral 4 con menos de 32 comandos, como que hay más no-ops al final de la cuadrícula.

Malbolge, 112 bytes

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

Voy a ver si hay uno más corto. Tengo una mejor computadora desde la última vez, por lo que puedo generar un poco más rápido.

Para el espectáculo, aquí está "¡Hola Mundo!" sin la coma

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

Fourier , 15 bytes

¡GRANDES CAMBIOS a Fourier!

`Hello, World!`

Pruébalo en FourIDE!

Sí, los días de escribir el código ASCII de cada personaje se han ido para siempre: Fourier ahora menos admite cadenas. Cuando encierra una cadena en backticks, esa cadena se generará.

Tenga en cuenta que no puede hacer nada más que generar esa cadena: no puede almacenarla en una variable, no está almacenada en el acumulador y no hay herramientas de manipulación de cadenas.

Aquí, puedes encontrar el choque de trenes que era el viejo Fourier. ;)

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

Pruébalo en línea!

Ahora, algunos de ustedes probablemente habrán conocido a Fourier antes y pueden estar bastante familiarizados con el idioma. Todo el lenguaje se basa en un acumulador: una variable global que utilizan prácticamente todos los operadores.

La parte más importante del código es el aoperador. Esto toma el valor numérico del acumulador y lo convierte en un carácter usando el código Python chr(accumulator). Esto se imprime en STDOUT.

Desafortunadamente, aún no he tenido la oportunidad de usar Fourier ( empujar empujar , guiño guiño ), principalmente debido a su falta de cadenas y operadores de cadenas. Aun así, sigue siendo útil para muchos otros desafíos (consulte la sección de ejemplos de su página EsoLangs).

Tenga en cuenta que esto es más corto que mi entrada en la lista de Esolangs porque en realidad no pensé que podría seguir jugando golf. Y luego, al escribir el desafío de golf de cuerda de Fourier, me di cuenta de que podía ir un poco más corto.

Nota

Si se preguntaba sobre la sintaxis variable, Geobits escribió un programa que usa variables y tiene la misma longitud:

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

Pruébalo en línea!

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

Desafortunadamente, el único compilador de C--, Quick C-- ya no se mantiene. Es un dolor en el cuello construir, pero es posible ...

C, 30 bytes

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

Bastante vainilla, pero no puedo pensar en una forma comúnmente compilable de hacerlo más corto (a menos que tal vez algún tipo de truco asm crudo funcione). Aún así, supera a la mayoría de esolangs!

Ilegible , 843 755 732 666 645 629 577 bytes

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

Se supone que los programas ilegibles se muestran con una fuente de ancho variable, por lo que respetan el nombre del idioma. Estoy un poco decepcionado de que mis enfoques más sofisticados resultaron ser mucho más largos. Los bucles son increíblemente caros en ilegible ...

Pruébalo en línea!

Cómo funciona

Ilegible tiene solo diez funciones; seis de estos se usan en este código:

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

Después de usar mi notación de un solo carácter y agregar algunos espacios en blanco y comentarios, el código anterior se parece a lo siguiente. Las declaraciones de varias líneas se ejecutan de abajo hacia arriba.

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

He generado el código fuente real ejecutando la versión no comentada del pseudocódigo anterior a través de este programa CJam .

Befunge 98 , 19 18 Bytes

Nueva respuesta (de undergroundmonorail)

"ck,@!dlroW ,olleH

Explicación

• " inicia el modo de cadena
• Todo lo que sigue es empujado a la pila. La pila es ahoraHello, World!@,kc
• Después de llegar al final, el intérprete vuelve al inicio
• Se encuentra de "nuevo, terminando el modo de cadena
• 12 es empujado a la pila ( c)
• k toma el valor superior de stack y ejecuta el siguiente comando que el puntero de instrucción puede ver muchas veces
• ,saca un valor de la pila y lo genera como un carácter. Ha sido ejecutado 12 veces por última kinstrucción, y una vez más cuando el intérprete realmente lee la ,instrucción
• @ termina el programa

La diferencia con la respuesta anterior es que reutilizamos inteligentemente el "personaje mediante el uso del comportamiento de bucle de Befunge cuando llega al final de la línea. Como puede ser menos intuitivo, también dejo el anterior. Además, es posible que haya notado que la pila todavía contiene algunos caracteres ( ck,@) debido a este buen truco, dejando un poco de desorden si alguna vez quisiéramos hacer algo después de eso.

Vieja respuesta

"!dlroW ,olleH"ck,@

Esto funciona para funge y befunge 98

Explicación

• Todo lo que ""está en medio se empuja a la pila. ( 'H'ahora está en la parte superior)
• c (12) es empujado a la pila
• k toma el valor superior de stack y ejecuta el siguiente comando que el puntero de instrucción puede ver muchas veces.
• ,saca un valor de la pila y lo genera como un carácter. Ha sido ejecutado 12 veces por última kinstrucción, y una vez más cuando el intérprete realmente lee la ,instrucción
• @ termina el programa

JSFuck , 6293 6289 6277 bytes

Esto puede ser mencionado como uno de los más largos "más cortos Hello, World! " (En realidad no sé si esto es óptimo, pero es el más corto que logré obtener).

Advertencia: solo funciona en Firefox y Safari

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

También hay una versión un poco más larga (+4 bytes) que también funciona en Chrome y Microsoft Edge:

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

Para aquellos que no están familiarizados con JSFuck, se trata de escribir JavaScript como si solo hubiera seis caracteres, y a veces puede volverse bastante loco.

¡Esta tabla muestra cómo los personajes se usaron en Hello, World! programa están codificados en JSFuck. El código de texto plano es 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                 |
+----------+--------------------------------------+---------------------------+

Aquí las cadenas "fill", "fontcolor"etc. deben escribirse como "f"+"i"+"l"+"l","f"+"o"+"n"+"t"+"c"+"o"+"l"+"o"+"r" para codificarse.

Los identificadores globales self, atoby btoase escriben como Function("return self")().

Functionen sí debería ser []["fill"]["constructor"].

La coma ","es complicada, no estoy 100% seguro de cómo funciona, pero utiliza la []["concat"]función para crear una matriz. Publicaré una actualización cuando tenga tiempo para hacer más pruebas.

Codifiqué esto usando JScrewIt: créditos para GOTO 0 por crear una herramienta tan sofisticada:

• Abra Firefox (puede elegir cualquier otro navegador, pero el código único de Firefox es el más corto).
• Navegue a JScrewIt : http://jscrew.it
• Entrada: alert("Hello, World!")
• Código ejecutable: marcado
• Compatibilidad: solo este navegador

Esto difiere de mi respuesta a esta pregunta por la presencia de la coma después de "Hola".

Curiosamente, la sintaxis de ES6

alert`Hello, World!`

toma incluso más bytes para codificar (+1500 más o menos) debido a la mayor complejidad de codificar dos backticks en lugar de ("y ").

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

Creo que esto es óptimo para un programa lineal (es decir, uno que no utiliza los operadores de flujo de control ?y *). Puede ser óptimo en general, pero no sé cómo hacer uso de esos operadores adicionales en una cantidad de código tan pequeña (o cómo explorar las posibilidades mediante programación).

El idioma ha sufrido algunos cambios recientemente después de que comencé a discutirlo con el autor por correo electrónico. Sin embargo, he escrito una implementación de referencia para el estado actual de la especificación del idioma la semana pasada, por lo que el código anterior es realmente ejecutable.

Metagolf

Originalmente, utilicé el resultado de mi implementación de referencia para este desafío y creé una solución hecha a mano basada en eso. Sin embargo, eso fue solo un enfoque heurístico.

Entonces, en su lugar, escribí un solucionador en Mathematica que realmente conoce las estructuras de datos y operadores de Pada para encontrar una solución óptima. En promedio, crece linealmente con la longitud de la cadena (aunque algunas combinaciones de caracteres son un poco más lentas que otras) y tardó aproximadamente 1,5 horas Hello, World!.

Entonces, ¿cómo hice para escribir el solucionador? Primero, notamos que solo necesitamos considerar 6 operadores: ~.oOqQ(más lo necesario wpara cada uno de los caracteres impresos). El uso de las pilas o los bloqueos de bits no es útil en el código lineal, y no lo creo ?y *se puede usar de manera efectiva en menos de 68 bytes.

El estado de Pada (ignorando las pilas y cerraduras) consta de 7 interruptores y 8 bits, organizados así:

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

Entonces eso es posible estados. Mi primer paso de preprocesamiento fue configurar un gráfico dirigido de estados donde cada borde corresponde a una sola operación. Es decir, el gráfico tiene 32768 vértices, cada uno con un grado de salida 6 (un borde de salida para cada una de las 6 operaciones bajo consideración). Podemos usar este gráfico para encontrar el camino más corto entre dos estados (este gráfico solo puede ser bastante útil para jugar al golf en Pada).215 = 32768

Ahora para cada personaje, queremos alcanzar un estado donde wimprima ese personaje. ¿Cuántos de esos estados hay? wlee el byte del bit en el que se suelta (cíclicamente). Entonces, hay 8 rotaciones posibles de los bits del carácter que pueden imprimir ese carácter. Para cada una de esas rotaciones, se fijan tres interruptores (para hacer wcaer en la posición correcta). Esto deja 4 interruptores arbitrarios. Entonces tenemos posibles estados para cada uno en nuestro código.8 * 24 = 128w

Con ellos podemos resolver otro problema gráfico: construya un gráfico que tenga un vértice de origen, luego una "capa" para cada personaje y un vértice de sumidero. Las capas consisten en 128 estados para cada vértice, el nodo fuente corresponde al estado inicial del programa (todos los interruptores a la izquierda y todos los bits son cero). El nodo sumidero no corresponde a ningún estado en particular. Tenemos bordes dirigidos desde cada vértice en una capa a cada vértice en la siguiente capa, donde el peso del borde es la distancia entre los dos estados en nuestro gráfico anterior. Los pesos de los bordes desde la última capa hasta el sumidero son todos 0. Es decir, podemos calcular previamente todos esos pesos de borde. Este es el paso más costoso del cálculo y tomó 1,5 horas Hello, World!.

Con este gráfico configurado, podemos encontrar el camino más corto desde la fuente hasta el sumidero con bastante rapidez (tardó 0.05s en mi máquina). Para Hello, World!los estados deseados son:

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

donde los 7 bits menos significativos corresponden a los interruptores y los 8 bits más significativos a los bits de Pada.

Ahora volvemos al primer gráfico y encontramos los bordes reales (es decir, operaciones) correspondientes a la ruta más corta entre cada par de estados posteriores, y terminamos cada uno de ellos con a w. Voilà, una solución óptima (basada en los supuestos anteriores).

Aquí está el Mathematica completo si alguien alguna vez quiere metagolf una cadena diferente en 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]) <> ""