Alors… euh… c'est un peu gênant. Mais nous n'avons pas un simple "Hello, World!" défi encore (malgré avoir 35 variantes étiquetées avec bonjour-monde , et comptant). Bien que ce ne soit pas le code de golf le plus intéressant dans les langues courantes, trouver la solution la plus courte dans certains esolangs peut être un sérieux défi. Par exemple, à ma connaissance, on ne sait pas si la solution de Brainfuck la plus courte possible a déjà été trouvée.

De plus, alors que toute la Wikipedia (l’entrée de Wikipedia a été supprimée mais qu’il existe une copie sur archive.org ), les esolangs et le code Rosetta ont des listes de "Hello, World!" programmes, aucun d’entre eux ne souhaite avoir le plus court pour chaque langue (il existe également ce référentiel GitHub ). Si nous voulons être un site important dans la communauté du code golf, je pense que nous devrions essayer de créer le catalogue ultime du plus court "Hello, World!" programmes (de la même manière que notre défi Quine de base contient certaines des quines les plus courtes connues dans diverses langues). Alors faisons ceci!

Les règles

• Chaque soumission doit être un programme complet.
• Le programme ne doit prendre aucune entrée et imprimer Hello, World!sur STDOUT (ce flux d'octets exact, y compris la capitalisation et la ponctuation) plus une nouvelle ligne de fin optionnelle, et rien d'autre.
• Le programme ne doit rien écrire dans STDERR.

• Si quelqu'un veut en abuser en créant un langage dans lequel le programme vide s'imprime Hello, World!, alors félicitations, ils ont simplement ouvert la voie à une réponse très ennuyeuse.

  Notez qu'il doit y avoir un interprète pour que la soumission puisse être testée. Il est permis (et même encouragé) d’écrire cet interprète vous-même pour une langue non encore implémentée.

• Les soumissions sont notées en octets , dans un codage approprié (préexistant), généralement (mais pas nécessairement) UTF-8. Certaines langues, comme les dossiers , sont un peu difficiles à noter - en cas de doute, demandez-les sur Meta .
• Il ne s'agit pas de trouver la langue avec le plus court "Hello, World!" programme. Il s’agit de trouver le plus court "Hello, World!" programme dans toutes les langues. Par conséquent, je ne marquerai aucune réponse comme "acceptée".
• Si votre langue de choix est une variante triviale d'une autre langue (potentiellement plus populaire) qui possède déjà une réponse (pensez aux dialectes BASIC ou SQL, aux shells Unix ou aux dérivés triviaux de Brainfuck comme Alphuck), pensez à ajouter une note à la réponse une solution identique ou très similaire est également la plus courte dans l’autre langue.

Notez également que les réponses ennuyeuses (mais valables) ne sont pas valables dans les langues où il n’ya pas grand chose à jouer au golf. Cependant, faites surtout des réponses dans des langues où les auteurs devaient réellement s’efforcer de jouer au code.

Pour vous inspirer, consultez la collection Hello World .

Le catalogue

L'extrait de pile au bas de cet article génère le catalogue à partir des réponses a) sous forme de liste des solutions les plus courtes par langue et b) sous forme de classement global.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

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

Coincé, 0 octet

Eh bien, je ne peux pas être plus court que ça ... Un programme vide sera affiché Hello, World!dans Stuck .

PHP, 13 octets

Hello, World!

Oui. Ça marche.

Brainfuck, 78 octets

Prime sans limite: Si quelqu'un peut améliorer ce score, je lui transmettrai la prime (+500). @KSaba trouvé unesolution de 76 72 octets!

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

Essayez-le en ligne!

Les 28 premiers octets --<-<<+[+[<+>--->->->-<<<]>]initialisent la bande avec la relation de récurrence suivante (mod 256):

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

Le facteur 171 est dû au fait que 3 ^-1 171 (mod 256) . Lorsque la valeur actuelle est convertie, une cellule (sous <+>---) en soustrayant 3 à chaque fois multiplie effectivement la valeur par 171.

Si n = 220, la valeur à traduire est zéro et l’itération s’arrête. Les dix octets précédant le point d'arrêt sont les suivants:

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

Celui-ci contient tous les composants nécessaires pour produire Hello, World!, à la chasse et au bec, des ajustements mineurs.

J'ai également trouvé une solution alternative à 78 octets:

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

Essayez-le en ligne!

Je considère que celui-ci est meilleur que le premier pour plusieurs raisons: il utilise moins de cellules de chez lui, il modifie moins de cellules au total et se termine plus rapidement.

Plus de détails

Les relations de récurrence ont des représentations étonnamment concises dans Brainfuck. La disposition générale est la suivante:

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

qui représente:

f _n = c _1. f _n-1 + c _2. f _n-2 + c _3. f _n-3 + ... + k

avec

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

De plus, le <+>peut être modifié pour multiplier la plage par une constante sans affecter le point d'arrêt, et un terme peut être ajouté avant >{k}pour décaler la plage d'une constante, sans affecter également le point d'arrêt.

Autres exemples

Séquence de Fibonacci

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

N-gonal nombres

Nombres triangulaires

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

Défini comme suit: f _n = 2. F _n-1 - f _n-2 + 1 , avec f ₀ = 0 , f ₁ = 1 .

Nombres Carrés

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

Nombres pentagonaux

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

etc.

BF Crunch

J'ai publié le code que j'ai utilisé pour trouver certaines de ces solutions sur github . Nécessite .NET 4.0 ou supérieur.

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 sortie est donnée en trois lignes:

1. Longueur totale du programme trouvé et du segment d'initialisation.
2. Chemin emprunté, en commençant par le pointeur de bande actuel. Chaque nœud correspond à un caractère de sortie, représenté par (pointeur, coût).
3. Segment de bande utilisé.

Par exemple, le résultat final pour bfcrunch "hello world" 70 -r -i23est:

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

Cela correspond au programme complet:

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

Autres enregistrements

Bonjour le monde!

Emballage, 78 octets :

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

ou

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

Non-wrapping, 87 octets (auparavant 92 octets (mitchs) ):

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

Bonjour le monde!

Emballage, 80 octets :

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

Non-wrapping, 81 octets (auparavant 92 octets (hirose) ):

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

Bonjour le monde!

Emballage, 74 octets :

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

Non enveloppant, 84 octets :

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

Version Esolangs

Bonjour tout le monde! \ N

Emballage, 76 octets :

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

Ceci utilise une cellule restante de la maison et serait donc considéré comme 77.

Non-wrapping, 83 octets :

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

Rdebath approuvé . sortie 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)

Bonjour le monde!

Emballage, 70 octets (auparavant 78 ¹ ):

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

Non-wrapping, 77 octets (auparavant 89?):

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

L'auteur affirme que le plus court code "Hello World!" est de 89 octets, mais ne fournit aucune référence. Je réclame le disque pour ceci aussi.

Bonjour le monde!

Emballage, 65 octets (auparavant 66 octets):

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

C’est aussi codé à la main (le meilleur que j’ai pu trouver en calculant est de 68 octets ). La première cellule est initialisée à 259 (3) et décrémentée de 7 à chaque itération en boucle 37 fois. La cellule suivante est décrémentée de 6, ce qui donne 256 - 6 · 37 = 34 . Le reste des cellules est décrémenté de 4 à chaque fois, en ajoutant une cellule à chaque itération, chaque nouvelle cellule étant inialisée à 252 (-4). Le résultat est le suivant:

[  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 solution donnée (79 octets) peut être réduite de manière triviale par un:

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

ArnoldC , 71 octets

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

Juste pour les lols ..

Graine , 6016 4234 4203 octets

20 854872453003476740699221564322673731945828554947586276010721089172712854441839676581917455319274850944955030258951339804246125714958815519550291630078076933441706558540342671975808828643360922071900333028778314875248417953197990571991784126564752005357199892690656368640420204822142316716413192024742766282266114842280731756458212469988291309261528542889299297601723286769284159107438930448971911102280330101196758384815655479640836157495863547199726234352265518586460633795171196315255736880028338460236768181141732764911402112878175632130129852788301009582463631290071329795384336617491655825493435803011947670180368458659271192428341035912236946048939139042310380278430049252171822721598175984923434205610723412240162418996808671543770639111617709604242882388664919702606792443015941265168129550718541372361144081848761690730764968771245566074501485020726368378675085908872608679630368472956274468410052703615106090238423979678950131481176272880569100533049143775921798055136871254424261001442543122666701145111965968366507060931708140304772342855064834334129143038575569044150428480231956133612367393837580345180691911525531699573096952433882387811884727975431823620782822755161559988205401134640722220804177812794328129589949692446031008866917615922944976151073653201316255518389496411696741029209242119521978920200314572718584995265523235225587228975886710511855501710470163649632761488899317729943053884132314641377747687975638119132094777769497069556255954031537245957811105217875011509899497752696062748928963281605780942517262774976217663461063680912331030221981433051827519906741285738915397005702326447635845195923640649166530310494885569783989508000344280715868581532826832242144647203531393142251025361866506821695860883605004105862208004440476654027574832078603305884731766236740069411566854496824754558761536201352147934963241039597221404341132342297870517293237489233057335406510464277610336142382379135365550299895416613763920950687921780736585299310706573253951966294045814905727514141733220565108490291792987304210662448111170752411153136765318541264632854767660676223663544921028492602135525959428999005153729028491208277493747933069008199074925710651071766675870081314909460661981433426167330215548196538791617762566403934129026219366764038390123622134753742930729751695349588862441999672547791630729398908283091638866715502470152431589429837867944760012419885615525232399584379209285060418518373512154801760060312646951597932345591416241634668119867158079946680321131213357200382937049485606706114467095019612014749723443159443363662563254359712162432143334612180576945072905749883870150120687696027984317320305291407322779803583395375616762530641605634303022155218169343410634115050596030685041633824154135240376022159918501703555881290333205131375705406831260759974112248490451605422031345264183102048614606636275942039438138959188478277971377232005036301145411215067576576667743288951344423152531417111852584846747428443123174595987315325304540564683047858415059703724263652136185848573853965992798725654430360647040362341567082462847275277303225817689141675391972818943419663764371222973269129542760661385278009266471167618553065823580448848795731295589715602705860758954890415040763604082216728159486423396295188510311881004469017351709060492844398219491990895826924575575549615118821417543037296628825303328056839433114519945243963946989899508355224823109677424196639930153649890175062456649384605721510239142861693109687536600667811037619175927995599388547421689316110236566026931360164495251160997857372500940728057700473763884480342708897319990346726967220426504612260565552531158509215849649565188655100774748485416791517853427613458459889062942881409801879085054494129489535044719193283409051007851153504224002807392992520076910314763705776345053922387355156981872691537772657428096384535960466923475731297217863371650154415835785630016335858514130863258775100537612371430357576913148500310344278511588325852376442503898849856566716198848377379400158332792027967216204970114516984638014129252882482309132898416484525230488700253065644547798869056136044415413099076332059572505138116227535024546891015836838323022822272664771489129085797354578016574544759934333471793

Le programme résultant Befunge-98 (basé sur ceci ) est

"9!dlroW ,olleH"ck,@

Croissant Mornington , 3614 3568 octets

Merci à NieDzejkob d’avoir économisé 46 octets en utilisant des noms de lignes plus courts.

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

Essayez-le en ligne!

Ceci est très certainement sous-optimal, mais représente la moitié de la solution sur les esolangs.

Hello, World est construit en découpant les noms de stations suivants et en concaténant les résultats:

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

Enfin, je calcule le code de caractère de !as (2<<4)+1 == 33. Toutes ces parties sont concaténées à Paddington et finalement imprimées à Mornington Crescent.

Remarque: la langue ne précise pas s'il est possible de se rendre deux fois de suite à la même station, mais l'interprète le permet. Je l'utilise donc.

mal , 70 octets

aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

Il utilise les quatre commandes suivantes:

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 octets

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

Essayez-le en ligne!

Et la solution originale de 76 octets sans emballage :

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

Essayez-le en ligne!

Autres solutions les plus courtes connues (à ma connaissance) que j'ai trouvées

'Bonjour le monde!' 77 octets:

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

Essayez-le en ligne!

'Bonjour le monde!' 70 octets:

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

Essayez-le en ligne!

Ceux-ci ont été trouvés en utilisant un programme c ++ que j'ai écrit ici: https://github.com/ksabry/bfbrute

Remarque: au départ, je voulais nettoyer ce code avant de le publier afin de le rendre quelque peu lisible et utilisable, mais comme je n'y suis pas parvenu depuis plus d'un an, je pense que je vais simplement le poster tel quel. Il fait un usage intensif des modèles et compile les constantes de temps pour toutes les optimisations potentielles. Il contient un tas de codes commentés de mes tests, mais aucun commentaire utile alors désolé, mais c'est un peu horrible.

Il n’ya rien de très malin dans le code, c’est un code brutal, mais il est tout à fait optimisé. L'optimisation majeure consiste à parcourir d'abord tous les programmes sans boucles (no [ou ]) jusqu'à une longueur spécifiée (16 actuellement) et à mettre en cache un tableau de toutes les modifications qu'il apportera au tableau de données. Il ne stocker qu'un seul programme par gamme unique de changements afin par exemple que l' un des >+<<->et <->>+<sera stocké. Il parcourt ensuite tous les programmes possibles qui sont composés de tout programme de ce cache avec une combinaison de boucles entre eux. Après avoir exécuté chaque programme, il effectue une simple chasse aux gourmands et pointe les personnages et les ajoute à la fin du programme.

Après avoir parcouru tous les programmes, j’ai remarqué que presque tous les programmes les plus courts (jusqu’à environ 19 ans) étaient de la forme *[*[*]*]. Restreindre la recherche aux programmes de cette forme a considérablement accéléré la recherche. Le détenteur actuel du record a été trouvé avec une longueur de 27. Celui-ci a en fait été calculé comme étant de longueur 74, mais j’ai remarqué une séquence particulière .>.>.>.qui a eu la chance d’avoir un 0 dans la cellule de données à sa droite, ce qui permet de la simplifier pour la [.>]<réduire. à 72.

Je l'ai laissé fonctionner pendant un bon bout de temps et complété la recherche avec les paramètres actuels jusqu'à la longueur 29, je suppose qu'il sera difficile de battre le système actuel en allant tout simplement plus haut. Je pense que l'approche la plus prometteuse serait probablement d'augmenter l'espace de recherche dans une manière intelligente.

Piet, 90 codels

Ceci est une image 30 par 3. Sinon, à la taille de code 10:

Le utilise une disposition de 3 haut afin que je n'ai besoin de pointeur une fois. Si cela reste golfable, je pourrais probablement raser tout au plus une autre colonne, car il existe un système push-pop no-op.

Edit: la solution de 84 codes de @ primo .

Meule de foin , 17 octets

Haystack est un langage de programmation 2D qui s'exécute jusqu'à ce qu'il trouve l'aiguille dans la botte de foin |, tout en effectuant des opérations basées sur des piles. Tous les programmes démarrent dans le coin supérieur gauche et peuvent utiliser les caractères directionnels ><^vpour se déplacer dans le programme. La direction est héritée, vous n’avez donc pas besoin de continuer à utiliser >pour aller à droite, la direction ne changera que si elle frappe un caractère directionnel différent.

Par défaut, l'interprète lit en haut à gauche et va à droite, on peut donc mettre "Hello, World!" sur la pile, utilisez-la opour l’imprimer, puis placez l’aiguille pour terminer l’exécution.

"Hello, World!"o|

Bonus: une version plus excitante:

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

Aidez-moi, WarDoq! , 1 octet

H

Non seulement Help, WarDoq! ont une syntaxe intégrée pour la plupart des orthographes courantes de la phrase, elle répond même à notre définition habituelle du langage de programmation.

Essayez-le dans l' interprète en ligne officiel (le code est entré en entrée ).

MarioLANG , 259 249 242 240 235 octets

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

Cela a été testé dans l'implémentation Ruby .

Après avoir obscurci "Hello, World!" à MarioLANG, j’ai un peu cherché à jouer au golf. Ce qui précède est le plus court que j'ai trouvé jusqu'à présent.

Comme auparavant, je suis parti d'une solution Brainfuck qui définit quatre cellules au multiple de 10 le plus proche, composé des caractères He,et de l'espace, et l'a converti en MarioLANG . Vous pouvez ensuite raccourcir un peu le code en utilisant le plancher auxiliaire dans la boucle, qui divise presque par deux la largeur de la boucle. Notez que le bas n'est exécuté qu'une fois de moins que le haut, de sorte que vous n'obtenez plus des multiples exacts du compteur initial dans les 4 cellules.

Enfin, je voulais utiliser l’espace perdu en face de la boucle et j’ai donc ajouté une série d’ascenseurs pour pouvoir utiliser l’espace vertical situé à cet endroit. Et ensuite, j'ai réalisé que je pouvais plier le code après la boucle (voir la révision précédente) en dessous de la boucle pour utiliser un peu plus d'espace vertical, ce qui économisait cinq octets supplémentaires.

C'est probablement encore loin d'être parfait, mais c'est une amélioration décente par rapport à la solution naïve, je pense.

Métagolf

Il est temps d'automatiser ...

J'ai commencé à configurer un solveur dans Mathematica pour trouver une solution optimale. Il suppose actuellement que la structure du code est fixe: compteur défini à 12, 4 cellules pour l'impression, avec l'affectation fixe He,<space>et le même ordre de ces cellules. Ce qui varie, c'est le nombre de +s dans la boucle ainsi que les corrections nécessaires par la suite:

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
 ]

Il s'avère que pour un compteur initial de 12, ma solution artisanale est déjà optimale. Cependant, utiliser 11 à la place enregistre deux octets. J'ai essayé toutes les valeurs de compteur de 6 à 20 (inclus) avec les résultats suivants:

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

Remarque: Ce solveur suppose que le code linéaire après la boucle est tout en haut de la ligne et que le code ci-dessus est cette solution repliée. Il pourrait y avoir une solution globale plus courte en informant le solveur du pliage, car j’obtiens maintenant 3 +s supplémentaires dans la première partie gratuitement, et les 4 instructions suivantes ne coûteraient qu’un octet au lieu de 2.

Sombre , 106 octets

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

Je laisserai simplement quelques citations de la spécification de langue parler de la brillance de cet esolang:

Dark est un langage basé sur la manipulation de mondes et de dimensions entiers pour atteindre des objectifs et construire la meilleure réalité possible.

Chaque fois qu'une erreur de syntaxe se produit, la santé du programme diminue de 1. [...] Si la santé du programme atteint zéro, l'interpréteur devient fou.

La corruption retourne un seul bit dans la variable lorsqu'elle survient.

Lorsque le maître meurt, toutes les variables de serviteur attachées à ce maître meurent également. Ceci est utile pour les variables de regroupement et de massacre.

Force une variable à se tuer, la libérant (rappelez-vous cependant qu'elle laissera une décomposition).

Définit une variable sur une valeur aléatoire. Utilise le générateur de chaos global.

Si un stalker n'est pas initialisé, toute tentative d'exécution d'E / S aura pour conséquence de réduire les messages d'erreur à écrire sur la console.

Homespring , 58 octets

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

L'espace de fuite est important.

Laissez-moi vous raconter une histoire. Il était une fois une centrale électrique qui alimentait une écloserie de saumon à proximité. L'écloserie de saumon a éclos un jeune saumon sans abri qui s'est embarqué dans un voyage en amont pour trouver un printemps. Il a effectivement trouvé un tel printemps, avec le nom poétique "Hello, World!", Où il a mûri et a engendré un nouveau jeune saumon. Les deux poissons ont maintenant nagé en aval, à la recherche du vaste océan. Mais juste avant l'embouchure de la rivière, il y avait un filet dans la rivière - le poisson mature était capturé et seul le jeune réussissait à se faufiler et atteignait l'océan et le reste de l'univers. Entre-temps, l'écloserie avait éclos davantage de saumons qui s'étaient également rendus en amont et avaient frayé et ainsi de suite.

Cependant, de grandes quantités de neige fondante s'étaient déplacées sur un autre bras de la rivière. Et juste après notre premier jeune saumon des sources de "Hello, World!" a atteint l'océan, la fonte des neiges a touché l'univers et ... euh ... l'a détruit. Et ils ont vécu heureux pour toujours… ou je suppose qu'ils ne l'ont pas fait.

Celles-ci étaient en réalité la sémantique du programme ci-dessus. Homespring est bizarre.

Chef , 465 octets

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.

Testé avec l'interprète Ruby. Fait la soupe à l'alphabet.

J'ai essayé d'être aussi conforme que possible à la spécification d'origine , alors même si l'interprète que j'ai utilisé vous laisse tomber les thes dans lePour contents instruction, je ne l'avais pas encore fait.

Le bol de mélange est assez cher, il pourrait donc y avoir une meilleure approche. J'ai essayé d'utiliser la conversion de base pour coder le message, mais malheureusement, la spécification ne précise pas si elle Divideutilise une division entière ou en virgule flottante, et l'interpréteur que j'ai utilise utilise cette dernière. Il n'y a pas non plus d'opérateur modulo, ce qui n'aide pas non plus.

Piet, 84 codels

28x3, ici représenté avec la largeur de code 10.

Créé avec PietDev , testé avec npiet . La présentation du programme est la suivante:

Le remplissage jaune indique les codes où le chemin se chevauche, le remplissage orange indique les codes qui doivent être de la même couleur, à des fins de contrôle du flux.

Pour aider à la création de ceci, j'ai écrit un interpréteur rudimentaire pour un langage basé sur des piles avec des commandes ressemblant à des commandes, que j'ai surnommé "pasm" ( source ). La sortie de cet interpréteur (avec cette entrée ) est la suivante:

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

Aucune commande de pointeur, de commutateur ou de défilement n'est utilisée. Aucun code n'est gaspillé non plus; en fait, deux sont réutilisés.

Espaces blancs , 192 150 146 octets

Les espaces ne nécessitent que des espaces, des tabulations et des sauts de ligne, les autres caractères étant ignorés.
Ce qui peut être gênant à afficher ici.
Donc, dans le code ci-dessous, les espaces et les onglets ont été remplacés.
Et un ';' a été placé devant les sauts de ligne pour plus de clarté.
Pour exécuter le code, remplacez d'abord. et> par des espaces et des tabulations.

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

Hexdump de code

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

Code d'assemblage des espaces:

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

Remarques:

J'ai dû écrire un programme juste pour calculer que l'ajout de 107 donne le golf optimal pour la phrase. Depuis la taille en octets qu'un entier prend dans les changements de code. : 4 + int (abs (log2 ($ n)))
Le code sera toujours exécuté sans la partie "e:" libellée et sortie sur whitespace.kauaveel.ee . Mais cela pourrait rendre le code d'espaces non valide sur d'autres compilateurs d'espaces. Ces octets ne sont donc pas liés à la solution.

Il faut noter que

Comme Kevin Cruijssen l'a souligné dans les commentaires, en autorisant une "sortie par erreur" selon la méta, le Whitespace peut comporter plus de 126 caractères pour le code de golf .

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

Assemblée:

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

Les versions antérieures de Java peuvent vous autoriser à utiliser un bloc statique (51 octets), mais je ne connais pas actuellement un moyen de contourner la mainméthode.

CSS, 30 octets

:after{content:"Hello, World!"

Les feuilles de style en cascade (CSS) ne sont pas un langage de programmation typique, mais elles peuvent assez bien produire des sorties fixes. Ceci est fait en créant un pseudo-élément après chaque élément avec le contenu Hello, World!. Donc, un seul élément ( <html>) est sélectionné, cela suppose que nous utilisons le document HTML le plus élémentaire, c'est-à-dire

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

Cela fonctionne dans la plupart des principaux navigateurs, à l'exception notable de Firefox, qui applique le sélecteur aux éléments <html>et <body>. C'est aussi la raison pour laquelle les extraits de pile ne fonctionnent pas, car il y a toujours un élément body qui est également stylé. Vous trouverez ci-dessous une version légèrement modifiée à tester.

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

HTML, 13 octets

Hello, World!

Le texte est automatiquement inséré dans le <body>, et est affiché.

Code machine x86_64 pour Linux, 32 octets

Lorsque Linux démarre un nouveau processus, tous les registres (sauf RSP) sont nuls. Nous pouvons donc obtenir RAX = 1 en modifiant uniquement l'octet inférieur. L’ABI System V x86-64 ne le garantit pas, mais c’est ce que fait réellement Linux. Ce code ne fonctionne que _startdans un exécutable statique.

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

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

L'instruction d'appel pousse l'adresse suivante, qui contient la chaîne hello world, dans la pile. Nous sautons l'adresse de la chaîne dansrsi .

Ensuite , les autres arguments sont mis en place pour syscalllasys_write qui imprime la chaîne.

Le programme se termine par un syscallto sys_exit. sys_writerenvoie le nombre d'octets écrits, donc les octets supérieurs de RAX sont nuls après le premier syscall(à moins qu'il ne renvoie une erreur), mov al, 60nous donne donc RAX =__NR_exit dans seulement 2 octets.

Vous pouvez faire que ce programme segfault en fermant sa stdout ( ./a.out >&-), donc sys_write()retournera -EBADF, la seconde syscallreviendra -ENOSYS, puis l'exécution tombera de la fin. Mais nous n'avons pas besoin de gérer les write()erreurs avec élégance.

Hexagony , 37 32 octets

Remarque: je donnerai une prime de 500 reps à la première personne qui trouve une solution valable dans un hexagone de côté 3 ou une solution manifestement optimale de côté 4. Si vous ne pouvez pas trouver une telle solution, parviens à battre mon score dans un hexagone de 4 côtés (en obtenant plus de no-ops à la fin du programme, ce qui peut être omis du code source), je suis disposé à donner une prime plus petite pour cela aussi .

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

Essayez-le en ligne!

Je suis fier de présenter mon deuxième langage de programmation 2D et (à ma connaissance) le tout premier langage 2D sur une grille hexagonale.

Le code source n'a pas l'air très 2D, n'est-ce pas? Eh bien, les espaces sont facultatifs dans Hexagony. Tout d'abord, le code source est complété avec le numéro hexagonal centré suivant avec no-ops ( .). Le nombre suivant est 37, nous insérons donc cinq non-opérations à la fin. Ensuite, le code source est réorganisé en hexagone régulier:

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

Ceci est également exécutable. Essayez-le en ligne!

Hexagony a un tas de fonctionnalités assez géniales, y compris 6 pointeurs d'instructions différents et une structure de mémoire qui est le graphique linéaire d'une grille hexagonale, mais ce code utilise seulement une adresse IP et un bord de mémoire, alors ne nous inquiétons pas de cela pour l'instant.

Voici un aperçu des commandes pertinentes:

• Les lettres définissent simplement le bord de la mémoire actuelle sur leur valeur ASCII
• ; affiche la valeur actuelle, modulo 256, sous forme d’octet dans STDOUT.
• / est un miroir qui se comporte comme vous le souhaitiez (l’adresse IP prend alors un virage à 120 degrés).
• Les chiffres fonctionnent comme dans Labyrinth : ils multiplient la cellule actuelle par 10, puis s'ajoutent.
• @ termine le programme.

Le problème final est que la source entoure les 3 paires d’arêtes. De plus, si l’IP quitte la grille par l’un des six coins, il y a deux rangées possibles. Le choix dépend de si la valeur actuelle est positive ou non positive. La version annotée suivante montre où l’IP rentre chaque fois qu’il quitte la grille:

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

Donc, si nous supprimons tous les changements de direction, ce programme se résume au code linéaire suivant:

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

Qu'est - ce avec Q2, P0et P1? Les lettres s’impriment facilement parce que nous pouvons simplement définir le bord à la valeur correspondante. Pour la virgule, l'espace et le point d'exclamation, cela ne fonctionne pas. Nous ne pouvons pas non seulement leur valeur fixé avec 44, 32, 33respectivement, parce que le bord de la mémoire est non nul pour commencer, et en raison de la sémantique des chiffres individuels qui infligerait toutes sortes de ravages. Si nous voulions le faire, nous aurions dû réinitialiser la valeur de bord à zéro avec quelque chose comme *, +, -, &ou ^premier. Cependant, étant donné que la valeur est prise modulo 256 avant d'être imprimée, il n'est pas nécessaire de définir exactement les valeurs sur 44, 32 ou 33. Par exemple, si vous utilisez moduloQ2 règlera la valeur de bord à 81*10 + 2 = 812, qui est44256 . De cette façon, nous pouvons enregistrer un octet sur chacun de ces trois caractères. (Malheureusement, il est jamais possible d'y arriver avec un seul chiffre de la valeur de la cellule a déjà. Amusante, où il ne le travail est oen World, parce que cela peut également être obtenu à partir W9.)

Vous pouvez utiliser ce script CJam pour rechercher toutes les combinaisons lettre-chiffre donnant un caractère donné.

Je ne suis pas sûr que ce soit optimal. Je doute qu’il soit possible de le faire dans un hexagone de longueur latérale 3 (où vous n’auriez que 19 caractères disponibles), mais il serait peut-être possible de le résoudre en hexagone de longueur latérale 4 avec moins de 32 commandes, telles que qu'il n'y a plus de no-ops à la fin de la grille.

Malbolge, 112 octets

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

Je vais voir s'il y en a un plus court. Vous avez un meilleur ordinateur depuis la dernière fois, je peux donc générer un peu plus rapidement.

Pour le spectacle, voici "Hello World!" sans la virgule.

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

Fourier , 15 octets

GRANDS CHANGEMENTS À Fourier!

`Hello, World!`

Essayez-le sur FourIDE!

Oui, le temps de saisir le code ASCII de chaque caractère est révolu: Fourier maintenant, genre de soutient des chaînes. Lorsque vous enfermez une chaîne dans des backticks, cette chaîne sera sortie.

Notez que vous ne pouvez rien faire d'autre que sortir cette chaîne: vous ne pouvez pas la stocker dans une variable, elle n'est pas stockée dans l'accumulateur et il n'y a pas d'outils de manipulation de chaîne.

Ici, vous pouvez trouver le naufrage du train qui était vieux Fourier. ;)

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

Essayez-le en ligne!

Certains d’entre vous auront probablement déjà rencontré Fourier et connaissent peut-être assez bien la langue. L'ensemble du langage est basé sur un accumulateur: une variable globale utilisée par la plupart des opérateurs.

La partie la plus importante du code est l' aopérateur. Ceci prend la valeur numérique de l'accumulateur et la convertit en un caractère utilisant le code Python chr(accumulator). Ceci est ensuite imprimé sur STDOUT.

Malheureusement, je n'ai pas encore eu la chance d'utiliser Fourier ( coup de pouce , clin d'oeil , clin d'oeil) ), principalement à cause de l'absence de chaînes et d'opérateurs de chaînes. Même dans ce cas, il reste utilisable pour de nombreux autres défis (voir la section exemples de sa page EsoLangs).

Notez que ceci est plus court que mon entrée dans la liste Esolangs parce que je ne pensais pas réellement que je pourrais jouer au golf plus longtemps . Et puis, en écrivant le défi du golf à cordes de Fourier, j'ai réalisé que je pouvais aller un peu plus court.

Remarque

Si vous vous interrogiez sur la syntaxe des variables, Geobits a écrit un programme qui utilise des variables et a la même longueur:

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

Essayez-le en ligne!

C-- , 155 octets

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

Malheureusement, le seul compilateur C connu, Quick C--, n'est plus maintenu. Il est une douleur dans le cou pour construire, mais il est possible ...

C, 30 octets

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

Vraiment vanille, mais je ne peux pas penser à un moyen couramment compilable de le faire plus court (à moins que peut-être une astuce brute ne marche pas?). Pourtant, bat la plupart des esolangs!

Illisible , 843 755 732 666 645 629 577 octets

« « ' « » » « « « » » » » « « « » « » « » » » « " « » « « « » » » « « « » » » « « « » » » »" « » "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "". « » « « » » « » « « » » « » « « » « » « » » « » « « » » « » « « « » » » « « « » » » « « « » » » " » "« « " » » « « « » » » « « « » » » « « « » » »" " « « « » » » « « « » » » « « « » » » « « « » » » « « " » » « « « » » » « « « » » » « « « » » » « « « » » » « « « » » » « « « » » » « « « » » »" » « » « « » » « » « « » » « » « » « » « « » « » « » « » » « » « « « » » » « « « » » » « « « » » » " » "« « " » » « « « » » » « « « » » » « » « »" " « » « « « » » » « « « » » » « « « » » » « « « » » » « « " » » « « « » » » « « « » » » « « « » » » « « « » » » « « « » » » « « « » » » « « « » » »" » « » « « » » « » « « » » « » « « » » « » " « »" « « « « » « » « » « « « » « » « » « » » » « » » » »« » « » « » « " « » » « " » « » « » « » « « « » » » « " « » « « « « « » » » « « « » » » » » »" « » "'" "" "" "" "" "" "" "" "" "" "" "" "". Différentes plusieurs plusieurs plusieurs différentes différentes différentes différentes différentes plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs] "" "" plusieurs plusieurs plusieurs plusieurs différentes plusieurs différentes différentes différentes "" plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs différentes plusieurs différentes plusieurs différentes différentes différentes plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs longions "" "" "plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs différentes plusieurs différentes plusieurs différentes plusieurs plusieurs plusieurs plusieurs" "" "" "" plusieurs plusieurs plusieurs plusieurs plusieurs plusieursions déc longions "" "". Un plusieurs plusieurs plusieurs plusieurs plusieursionsch long long "" "plusieurs plusieurs plusieurs plusieurs plusieurs plusieursions plusieursions plusieurs longue plusieurs longue plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs plusieursions plusieursions plusieurs fins plusieurs long plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs plusieursions plusieursions plusieursions plusieurs long" "plusieurs plusieurs plusieurs plusieurs plusieurs plusieurs plusieursions plusieursions" "" "" "" "" "" "" "" "" "" "" "" "" ""« » « « » « « « « « » » » « « « » » » » » « « « » » » « « « » « » « » « « « » » » « » » » » « » « » « » « « « » » » « » « « « « » « » « » « « « » » » « « « » » » « » » » » « » « « » « » « »" » « »"« » « « » « « « « « » » » « « « » » » » » « « « » » » « « « » « » « » « « « » » » « » » » » « » « » « » « « « » » » « » « « « « » « » « » « « « » » » « « « » » » « » » » » « » « « » « » « »" » « »"« » « « « » » » « » « « « « » « » « » « « « » » » « « « » » » « » » » » « » « « » « » « »" » « »"« » « « « » » » « » « « « « » « » « » « « « » » » « « « » » » « » » » » « » « « » « » « »" » « »"

Les programmes illisibles sont supposés être affichés avec une police à largeur variable, ils respectent donc le nom de la langue. Je suis un peu déçu que mes approches plus sophistiquées se soient avérées beaucoup plus longues. Les boucles sont incroyablement chères dans Illisible ...

Essayez-le en ligne!

Comment ça fonctionne

Illisible n'a que dix fonctions; six d'entre eux sont utilisés dans ce code:

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

Après avoir utilisé ma notation à caractère unique et ajouté des espaces et des commentaires, le code ci-dessus ressemble à ce qui suit. Les instructions multilignes sont exécutées de bas en haut.

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

J'ai généré le code source réel en exécutant la version non commentée du pseudo -code ci-dessus via ce programme CJam .

Befunge 98 , 19 18 octets

Nouvelle réponse (de undergroundmonorail)

"ck,@!dlroW ,olleH

Explication

• " démarre le mode chaîne
• Tout ce qui suit est mis dans la pile. La pile est maintenantHello, World!@,kc
• Après avoir touché la fin, l'interprète revient au début
• Il rencontre à "nouveau, terminant le mode chaîne
• 12 est poussé dans la pile ( c)
• k prend la valeur supérieure de pile et exécute la commande suivante que le pointeur d'instruction peut voir autant de fois
• ,extrait une valeur de la pile et la sort comme un caractère. Il a été exécuté 12 fois par la dernière kinstruction et une fois de plus lorsque l'interprète lit l' ,instruction.
• @ termine le programme

La différence avec l'ancienne réponse est que nous réutilisons intelligemment le "personnage en utilisant le comportement de boucle de Befunge quand il atteint la fin de la ligne. Comme il est peut-être moins intuitif, je laisse l’ancien aussi. En outre, vous avez peut-être remarqué que la pile contiendra toujours des caractères ( ck,@) à cause de cette astuce, laissant des dégâts si nous voulions faire quelque chose par la suite.

Ancienne réponse

"!dlroW ,olleH"ck,@

Cela fonctionne pour funge et befunge 98

Explication

• Tout entre ""est poussé à la pile. ( 'H'est maintenant sur le dessus.)
• c (12) est poussé à la pile
• k prend la valeur supérieure de stack et exécute la commande suivante que le pointeur d'instruction peut voir à plusieurs reprises.
• ,extrait une valeur de la pile et la sort comme un caractère. Il a été exécuté 12 fois par la dernière kinstruction et une fois de plus lorsque l'interprète lit l' ,instruction.
• @ termine le programme

JSFuck , 6293 6289 6277 octets

Cela peut être mentionné comme l’un des programmes les plus longs " Bonjour, Monde! " (En fait, je ne sais pas si c’est optimal, mais c’est le plus court que j’ai réussi à obtenir).

Attention: ne fonctionne que dans Firefox et Safari

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

Il existe également une version légèrement plus longue (+4 octets) qui fonctionne également dans Chrome et Microsoft Edge:

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

Pour ceux qui ne connaissent pas JSFuck, il s'agit d'écrire du code JavaScript comme s'il n'y avait que six caractères, et cela peut parfois devenir assez fou.

Ce tableau montre comment les caractères utilisés dans Hello, World! programme sont encodés en JSFuck. Le code en clair est juste 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                 |
+----------+--------------------------------------+---------------------------+

Ici, les chaînes "fill", "fontcolor"etc. doivent être écrites comme suit "f"+"i"+"l"+"l":"f"+"o"+"n"+"t"+"c"+"o"+"l"+"o"+"r" à coder.

Les identificateurs globaux self, atobet btoaécris comme Function("return self")().

Functionlui-même devrait être []["fill"]["constructor"].

La virgule ","est délicate, je ne suis pas sûr à 100% de son fonctionnement, mais la []["concat"]fonction est utilisée pour créer un tableau. Je posterai une mise à jour lorsque j'aurai le temps de faire d'autres tests.

J'ai encodé ceci en utilisant JScrewIt - crédits à GOTO 0 pour la création d'un outil aussi sophistiqué:

• Ouvrez Firefox (vous pouvez choisir n’importe quel autre (s) navigateur (s), mais seul le code Firefox est le plus court.)
• Accédez à JScrewIt : http://jscrew.it
• Contribution: alert("Hello, World!")
• Code exécutable: vérifié
• Compatibilité: Seulement ce navigateur

Cela diffère de ma réponse à cette question pour la présence de la virgule après "Bonjour".

Fait intéressant, la syntaxe ES6

alert`Hello, World!`

prend encore plus d'octets à encoder (environ +1500) en raison de la complexité accrue de l'encodage de deux backticks plutôt que de ("et ").

Pada , 83 68 octets

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

Je pense que ceci est optimal pour un programme linéaire (c'est-à-dire qui n'utilise pas les opérateurs de flux de contrôle ?et* ). Dans l’ensemble, c’est peut-être optimal, mais je ne sais pas comment utiliser ces opérateurs supplémentaires dans une si petite quantité de code (ni comment explorer les possibilités par programmation).

La langue a récemment subi quelques modifications après que j'ai commencé à en discuter avec l'auteur par courrier électronique. Cependant, j'ai écrit une implémentation de référence pour l'état actuel de la spécification de langage la semaine dernière, de sorte que le code ci-dessus est réellement exécutable.

Métagolf

À l'origine, j'avais utilisé le résultat de mon implémentation de référence pour relever ce défi et créé une solution conçue à la main à partir de cela. Cependant, ce n’était qu’une approche heuristique.

Au lieu de cela, j’ai donc écrit un solveur dans Mathematica, qui connaît les structures de données et les opérateurs de Pada afin de trouver une solution optimale. En moyenne, il croît linéairement avec la longueur de la chaîne (bien que certaines combinaisons de caractères soient un peu plus lentes que d'autres) et prenait environ 1,5 heure Hello, World!.

Alors, comment je me suis mis à écrire le solutionneur. Tout d’abord, nous remarquons qu’il ne faut prendre en compte que 6 opérateurs: ~.oOqQ(plus le nécessaire wpour chacun des caractères imprimés). L'utilisation des piles ou des verrous de bits n'est pas utile en code linéaire, et je ne le crois pas, ?et *peut être utilisée efficacement en moins de 68 octets.

L'état de Pada (ignorant les piles et les verrous) consiste en 7 commutateurs et 8 bits, disposés comme suit:

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

C'est donc des états possibles. Ma première étape de prétraitement a été de créer un graphe d’états dirigé où chaque bord correspond à une seule opération. En d'autres termes, le graphique comporte 32 768 sommets, chacun avec un degré extérieur égal à 6 (un bord sortant pour chacune des 6 opérations considérées). Nous pouvons utiliser ce graphique pour trouver le chemin le plus court entre deux états (ce graphique à lui seul peut être très utile pour jouer au golf à Pada).215 = 32768

Maintenant, pour chaque personnage, nous voulons atteindre un état où wce personnage est imprimé. Combien y a-t-il de tels états? wlit l'octet à partir du bit sur lequel il est déposé (de manière cyclique). Il y a donc 8 rotations possibles des bits du caractère qui peuvent tous imprimer ce caractère. Pour chacune de ces rotations, trois interrupteurs sont fixes (afin de faire wchuter dans la bonne position). Cela laisse 4 commutateurs arbitraires. Nous avons donc des états possibles pour chacun dans notre code.8 * 24 = 128w

Avec ceux-ci, nous pouvons résoudre un autre problème de graphe: construire un graphe qui a un sommet source, puis un "calque" pour chaque caractère et un sommet creux. Les couches sont constituées de 128 états pour chaque sommet, le nœud source correspond à l'état initial du programme (tous les commutateurs sont à gauche et tous les bits sont à zéro). Le noeud collecteur ne correspond à aucun état en particulier. Nous avons des arêtes dirigées de chaque sommet d'une couche à chaque sommet de la couche suivante, où l'épaisseur de l'arête est la distance entre les deux états de notre graphique précédent. Les poids des arêtes de la dernière couche à l'évier sont tous égaux à 0. Autrement dit, nous pouvons précalculer tous ces poids d'arête. C’est l’étape la plus coûteuse du calcul et elle a pris 1,5 heure Hello, World!.

Avec ce graphique mis en place, nous pouvons trouver le chemin le plus court de la source à l’évier assez rapidement (il a fallu 0,05 s sur ma machine). Pour Hello, World!les états souhaités sont:

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

où les 7 bits les moins significatifs correspondent aux commutateurs et les 8 bits les plus significatifs aux bits de Pada.

Maintenant, revenons au premier graphique et trouvons les arêtes réelles (opérations) correspondant au chemin le plus court entre chaque paire d'états suivants, et finissons-en chacun par un w. Voilà, une solution optimale (basée sur les hypothèses ci-dessus).

Voici le Mathematica complet si quelqu'un veut métagolfer une corde différente à 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]) <> ""