Also ... äh ... das ist ein bisschen peinlich. Aber wir haben kein einfaches "Hallo, Welt!" Herausforderung noch (trotz 35 Varianten mit hallo-Welt getaggt und zu zählen). Während dies nicht das interessanteste Codegolf in den gängigen Sprachen ist, kann es eine ernsthafte Herausforderung sein, in bestimmten Esolangs die kürzeste Lösung zu finden. Zum Beispiel ist meines Wissens noch nicht bekannt, ob die kürzestmögliche Brainfuck-Lösung gefunden wurde.

Während die gesamte Wikipedia (der Wikipedia-Eintrag wurde gelöscht , es gibt jedoch eine Kopie bei archive.org ), haben esolangs und Rosetta Code Listen mit "Hello, World!" Keines dieser Programme ist daran interessiert, das kürzeste für jede Sprache zu haben (es gibt auch dieses GitHub-Repository ). Wenn wir eine bedeutende Site in der Code-Golf-Community sein wollen, sollten wir versuchen, den ultimativen Katalog der kürzesten "Hallo, Welt!" Programme (ähnlich wie unsere grundlegende Quine-Herausforderung einige der kürzesten bekannten Quines in verschiedenen Sprachen enthält). Also lass uns das machen!

Die Regeln

• Jede Einreichung muss ein vollständiges Programm sein.
• Das Programm muss keine Eingaben Hello, World!vornehmen und auf STDOUT (genau dieser Byte-Stream, einschließlich Groß- und Kleinschreibung und Interpunktion) plus optionalem abschließendem Zeilenumbruch und sonst nichts drucken.
• Das Programm darf nichts nach STDERR schreiben.

• Wenn jemand dies missbrauchen will, indem er eine Sprache erstellt, in der das leere Programm gedruckt wird Hello, World!, dann herzlichen Glückwunsch, dann hat er gerade den Weg für eine sehr langweilige Antwort geebnet.

  Beachten Sie, dass ein Dolmetscher vorhanden sein muss, damit die Einreichung getestet werden kann. Es ist erlaubt (und sogar empfohlen), diesen Dolmetscher für eine zuvor nicht implementierte Sprache selbst zu schreiben.

• Einsendungen werden in Bytes in einer geeigneten (bereits vorhandenen) Codierung bewertet, normalerweise (aber nicht unbedingt) in UTF-8. Einige Sprachen, wie Ordner , sind etwas schwierig zu bewerten - im Zweifelsfall fragen Sie bitte bei Meta nach .
• Es geht nicht darum, die Sprache mit dem kürzesten "Hallo Welt!" Programm. Hier geht es darum, die kürzeste "Hallo, Welt!" Programm in jeder Sprache. Daher werde ich keine Antwort als "akzeptiert" markieren.
• Wenn Ihre gewählte Sprache eine triviale Variante einer anderen (möglicherweise populäreren) Sprache ist, die bereits eine Antwort enthält (denken Sie an BASIC- oder SQL-Dialekte, Unix-Shells oder triviale Brainfuck-Derivate wie Alphuck), sollten Sie der vorhandenen Antwort eine Anmerkung hinzufügen, die die gleiche oder sehr ähnliche Lösung ist auch die kürzeste in der anderen Sprache.

Nebenbei bemerkt, stimmen Sie langweiligen (aber gültigen) Antworten in Sprachen, in denen es nicht viel zu Golf gibt, nicht ab - diese sind für diese Frage nach wie vor hilfreich, da versucht wird, einen Katalog so vollständig wie möglich zusammenzustellen. Allerdings tun in erster Linie upvote Antworten in Sprachen , in denen die tatsächlich hatten Autoren Mühe in den Code Golf spielen.

Inspiration finden Sie in der Hello World Collection .

Der Katalog

Das Stapel-Snippet am Ende dieses Beitrags generiert den Katalog aus den Antworten a) als Liste der kürzesten Lösungen pro Sprache und b) als Gesamt-Bestenliste.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

## Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Snippet angezeigt wird:

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

Feststecken, 0 Bytes

Naja, kann nicht kürzer werden ... Ein leeres Programm wird Hello, World!in Stuck ausgegeben .

PHP, 13 Bytes

Hello, World!

Ja. Es klappt.

Brainfuck, 78 Bytes

Unbefristetes Kopfgeld: Wenn jemand diese Punktzahl verbessern kann, werde ich das Kopfgeld (+500) an ihn weitergeben. @KSabhat eine gefunden 76 72 Byte Lösung!

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

Probieren Sie es online!

Die ersten 28 Bytes --<-<<+[+[<+>--->->->-<<<]>]initialisieren das Band mit der folgenden Wiederholungsrelation (Mod 256):

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

Der Faktor 171 ergibt sich aus 3 ^-1 ≡ 171 (mod 256) . Wenn der aktuelle Wert übersetzt wird, <+>---multipliziert eine Zelle (über ), die jedes Mal 3 subtrahiert, den Wert effektiv mit 171.

Bei n = 220 ist der zu übersetzende Wert Null und die Iteration stoppt. Die zehn Bytes vor dem Stoppunkt lauten wie folgt:

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

Dieser enthält alle Komponenten, die für die Produktion Hello, World!mit nur geringfügigen Anpassungen im Handumdrehen erforderlich sind .

Ich habe auch eine alternative 78-Byte-Lösung gefunden:

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

Probieren Sie es online!

Ich halte diesen aus mehreren Gründen für besser als den ersten: Er verwendet weniger Zellen, die noch zu Hause sind, ändert insgesamt weniger Zellen und endet schneller.

Mehr Details

Wiederholungsrelationen sind in Brainfuck überraschend knapp dargestellt. Das allgemeine Layout ist das folgende:

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

welcher ... repräsentiert:

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

mit

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

Zusätzlich kann der <+>Wert geändert werden, um den Bereich mit einer Konstanten zu multiplizieren, ohne den Stoppunkt zu beeinflussen, und ein Term kann vor dem >{k}Wert hinzugefügt werden , um den Bereich um eine Konstante zu verschieben, wiederum ohne den Stoppunkt zu beeinflussen.

Andere Beispiele

Fibonacci-Folge

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

N-gonale Zahlen

Dreieckige Zahlen

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

Definiert als f _n = 2 · f _n-1 - f _n-2 + 1 mit f ₀ = 0 , f ₁ = 1 .

Quadratzahl

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

Fünfeckige Zahlen

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

usw.

BF Crunch

Ich habe den Code veröffentlicht, mit dem ich einige dieser Lösungen auf github gefunden habe . Benötigt .NET 4.0 oder höher.

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.

Die Ausgabe erfolgt in drei Zeilen:

1. Gesamtlänge des gefundenen Programms und des Initialisierungssegments.
2. Pfad genommen, beginnend mit dem aktuellen Bandzeiger. Jeder Knoten entspricht einem Ausgabezeichen, dargestellt als (Zeiger, Kosten).
3. Ausgenutztes Bandsegment.

Das Endergebnis für bfcrunch "hello world" 70 -r -i23lautet beispielsweise:

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

Dies entspricht dem vollen Programm:

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

Andere Aufzeichnungen

Hallo Welt!

Umbruch, 78 Bytes :

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

oder

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

Nicht umlaufend , 87 Bytes (vorher 92 Bytes (Mitchs) ):

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

Hallo Welt!

Umbruch, 80 Bytes :

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

Nicht umhüllend, 81 Bytes (vorher 92 Bytes (Hirose) ):

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

Hallo Welt!

Umbruch, 74 Bytes :

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

Nicht umhüllend, 84 Bytes :

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

Esolangs Version

Hallo Welt! \ N

Umbruch, 76 Bytes :

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

Dies verwendet eine Zelle, die noch zu Hause ist, und würde daher als 77 betrachtet werden.

Nicht umhüllend, 83 Bytes :

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

Rdebath genehmigt . Profilebf-Ausgabe:

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)

Hallo Welt!

Umbruch, 70 Bytes (vorher 78 ¹ ):

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

Nicht umlaufend, 77 Bytes (vorher 89?):

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

Der Autor behauptet, dass die kürzeste handcodierte "Hallo Welt!" ist 89 Bytes, bietet aber keine Referenz. Hiermit beanspruche ich auch den Rekord.

Hallo Welt!

Umbruch, 65 Bytes (vorher 66 Bytes):

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

Dies ist tatsächlich auch handcodiert (das Beste, was ich durch Knirschen finden konnte, sind 68 Bytes ). Die erste Zelle wird auf 259 (3) initialisiert und bei jeder Iteration um 7 dekrementiert, wobei eine 37-fache Schleife durchgeführt wird. Die nächste Zelle wird um 6 dekrementiert, was zu 256 - 6 · 37 = 34 führt . Die restlichen Zellen werden jedes Mal um 4 dekrementiert, wobei jede Iteration eine Zelle hinzufügt und jede neue Zelle auf 252 (-4) initialisiert wird. Das Ergebnis ist das Folgende:

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

¹ Die angegebene Lösung (79 Bytes) kann trivial um eins reduziert werden:

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

ArnoldC , 71 Bytes

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

Nur für lols ..

Seed , 6016 4234 4203 Bytes

20 854872453003476740699221564322673731945828554947586276010721089172712854441839676581917455319274850944955030258951339804246125714958815519550291630078076933441706558540342671975808828643360922071900333028778314875248417953197990571991784126564752005357199892690656368640420204822142316716413192024742766282266114842280731756458212469988291309261528542889299297601723286769284159107438930448971911102280330101196758384815655479640836157495863547199726234352265518586460633795171196315255736880028338460236768181141732764911402112878175632130129852788301009582463631290071329795384336617491655825493435803011947670180368458659271192428341035912236946048939139042310380278430049252171822721598175984923434205610723412240162418996808671543770639111617709604242882388664919702606792443015941265168129550718541372361144081848761690730764968771245566074501485020726368378675085908872608679630368472956274468410052703615106090238423979678950131481176272880569100533049143775921798055136871254424261001442543122666701145111965968366507060931708140304772342855064834334129143038575569044150428480231956133612367393837580345180691911525531699573096952433882387811884727975431823620782822755161559988205401134640722220804177812794328129589949692446031008866917615922944976151073653201316255518389496411696741029209242119521978920200314572718584995265523235225587228975886710511855501710470163649632761488899317729943053884132314641377747687975638119132094777769497069556255954031537245957811105217875011509899497752696062748928963281605780942517262774976217663461063680912331030221981433051827519906741285738915397005702326447635845195923640649166530310494885569783989508000344280715868581532826832242144647203531393142251025361866506821695860883605004105862208004440476654027574832078603305884731766236740069411566854496824754558761536201352147934963241039597221404341132342297870517293237489233057335406510464277610336142382379135365550299895416613763920950687921780736585299310706573253951966294045814905727514141733220565108490291792987304210662448111170752411153136765318541264632854767660676223663544921028492602135525959428999005153729028491208277493747933069008199074925710651071766675870081314909460661981433426167330215548196538791617762566403934129026219366764038390123622134753742930729751695349588862441999672547791630729398908283091638866715502470152431589429837867944760012419885615525232399584379209285060418518373512154801760060312646951597932345591416241634668119867158079946680321131213357200382937049485606706114467095019612014749723443159443363662563254359712162432143334612180576945072905749883870150120687696027984317320305291407322779803583395375616762530641605634303022155218169343410634115050596030685041633824154135240376022159918501703555881290333205131375705406831260759974112248490451605422031345264183102048614606636275942039438138959188478277971377232005036301145411215067576576667743288951344423152531417111852584846747428443123174595987315325304540564683047858415059703724263652136185848573853965992798725654430360647040362341567082462847275277303225817689141675391972818943419663764371222973269129542760661385278009266471167618553065823580448848795731295589715602705860758954890415040763604082216728159486423396295188510311881004469017351709060492844398219491990895826924575575549615118821417543037296628825303328056839433114519945243963946989899508355224823109677424196639930153649890175062456649384605721510239142861693109687536600667811037619175927995599388547421689316110236566026931360164495251160997857372500940728057700473763884480342708897319990346726967220426504612260565552531158509215849649565188655100774748485416791517853427613458459889062942881409801879085054494129489535044719193283409051007851153504224002807392992520076910314763705776345053922387355156981872691537772657428096384535960466923475731297217863371650154415835785630016335858514130863258775100537612371430357576913148500310344278511588325852376442503898849856566716198848377379400158332792027967216204970114516984638014129252882482309132898416484525230488700253065644547798869056136044415413099076332059572505138116227535024546891015836838323022822272664771489129085797354578016574544759934333471793

Das resultierende Befunge-98-Programm (basierend auf diesem ) ist

"9!dlroW ,olleH"ck,@

Mornington Crescent , 3614 3568 Bytes

Dank an NieDzejkob für die Einsparung von 46 Bytes durch Verwendung kürzerer Zeilennamen.

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

Probieren Sie es online!

Dies ist sicherlich nicht optimal, aber es ist halb so groß wie die Lösung für Esolangs.

Hello, World wird erstellt, indem die folgenden Stationsnamen aufgeschnitten und die Ergebnisse verkettet werden:

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

Schließlich berechne ich den Zeichencode von !as (2<<4)+1 == 33. Alle diese Teile werden in Paddington verkettet und schließlich in Mornington Crescent gedruckt.

Hinweis: Die Sprache gibt nicht an, ob es möglich ist, zweimal hintereinander zum gleichen Bahnhof zu fahren, aber der Dolmetscher lässt dies zu, sodass ich davon Gebrauch gemacht habe.

böse , 70 Bytes

aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

Es werden die folgenden vier Befehle verwendet:

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

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

Probieren Sie es online!

Und die ursprüngliche nicht umhüllende 76-Byte- Lösung:

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

Probieren Sie es online!

Andere kürzeste bekannte (meines Wissens) Lösungen, die ich gefunden habe

'Hallo Welt!' 77 Bytes:

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

Probieren Sie es online!

'Hallo Welt!' 70 Bytes:

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

Probieren Sie es online!

Diese wurden mit einem C ++ - Programm gefunden, das ich hier geschrieben habe: https://github.com/ksabry/bfbrute

Hinweis: Ich wollte diesen Code ursprünglich bereinigen, bevor ich ihn veröffentlichte, damit er tatsächlich einigermaßen lesbar und verwendbar ist. Da ich mich jedoch seit über einem Jahr nicht darum gekümmert habe, werde ich ihn einfach so veröffentlichen, wie er ist. Es nutzt Vorlagen und Kompilierzeitkonstanten stark für mögliche Optimierungen und es enthält eine Reihe von auskommentiertem Code aus meinen Tests, aber keine hilfreichen Kommentare. Tut mir leid, aber es ist ein bisschen schrecklich.

Der Code hat nichts Schreckliches an sich, er ist im Kern ein Brute Forcer, aber er ist ziemlich optimiert. Die Hauptoptimierung besteht darin, dass zuerst alle Programme ohne Schleifen (no [oder ]) bis zu einer festgelegten Länge (derzeit 16) durchlaufen werden und ein Array aller Änderungen zwischengespeichert wird, die am Datenarray vorgenommen werden. Es wird nur ein einziges Programm pro eindeutigem Array von Änderungen gespeichert, also beispielsweise nur eines von >+<<->und <->>+<. Es durchläuft dann alle möglichen Programme, die aus einem beliebigen Programm in diesem Cache bestehen, mit einer beliebigen Kombination von Schleifen zwischen diesen. Nach dem Ausführen jedes Programms macht es eine einfache gierige Suche und sucht nach den Zeichen und hängt diese an das Ende des Programms an.

Nachdem ich dies durch den Raum aller Programme gelaufen war, bemerkte ich, dass fast alle kürzesten Programme (bis zu einer Länge von ~ 19) von der Form waren *[*[*]*]. Die Einschränkung der Suche auf Programme dieses Formats hat die Suche erheblich beschleunigt. Der aktuelle Rekordhalter wurde bei Länge 27 gefunden. Dieser wurde tatsächlich mit Länge 74 berechnet, aber ich bemerkte eine bestimmte Sequenz, .>.>.>.die das Glück hatte, eine 0 in der Datenzelle zu haben, damit sie vereinfacht [.>]<und heruntergefahren werden konnte bis 72.

Ich habe es eine Weile laufen lassen und die Suche mit den aktuellen Parametern bis zur Länge 29 abgeschlossen. Ich vermute, dass es schwierig sein wird, die aktuelle zu übertreffen, wenn man einfach höher geht. Ich denke, der vielversprechendste Ansatz wäre wahrscheinlich, den Suchraum in zu vergrößern eine intelligente Art und Weise.

Piet, 90 Codels

Dies ist ein 30 mal 3 Bild. Alternativ bei Codelgröße 10:

Das verwendet ein 3-Hoch-Layout, so dass ich nur einmal auf etwas zeigen muss. Wenn das noch golffähig ist, könnte ich wahrscheinlich höchstens eine andere Kolumne rasieren, da dort ein Push-Pop-No-Op drin ist.

Edit: @primos 84 Codelösung .

Heuhaufen , 17 Bytes

Haystack ist eine 2D-Programmiersprache, die ausgeführt wird, bis die Nadel im Heuhaufen gefunden ist |, während stapelbasierte Operationen ausgeführt werden. Alle Programme beginnen in der oberen linken Ecke und können mithilfe der Richtungszeichen ><^vim Programm navigieren. Die Richtung wird vererbt, sodass Sie nicht weiter verwenden müssen, um >nach rechts zu gehen. Die Richtung ändert sich nur, wenn ein anderes Richtungszeichen getroffen wird.

Standardmäßig liest der Interpreter von links oben nach rechts oben, also können wir einfach "Hallo Welt!" Auf den Stapel olegen , zum Drucken verwenden und die Nadel platzieren, um die Ausführung zu beenden.

"Hello, World!"o|

Bonus: Eine aufregendere Version:

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

Hilfe, WarDoq! 1 Byte

H

Nicht nur , dass Hilfe, WarDoq! Mit der für die meisten gängigen Schreibweisen des Ausdrucks integrierten Funktion wird sogar unsere übliche Definition der Programmiersprache erfüllt.

Probieren Sie es im offiziellen Online-Dolmetscher aus (Code geht in die Eingabe ).

MarioLANG , 259 249 242 240 235 Bytes

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

Dies wurde in der Ruby-Implementierung getestet .

Nach der Verschleierung "Hallo, Welt!" in MarioLANG habe ich mich ein bisschen mit dem Golfen beschäftigt. Das obige ist das kürzeste, das ich bisher gefunden habe.

Wie zuvor bin ich von einer Brainfuck-Lösung ausgegangen, bei der vier Zellen auf das nächste Vielfache von 10 für die Zeichen He,und das Leerzeichen gesetzt und in MarioLANG konvertiert wurden . Sie können den Code dann ein wenig verkürzen, indem Sie den Zusatzboden in der Schleife verwenden, der die Breite der Schleife fast halbiert. Beachten Sie, dass der untere Teil nur einmal weniger ausgeführt wird als der obere Teil, sodass Sie nicht mehr in allen 4 Zellen exakte Vielfache des anfänglichen Zählers erhalten.

Schließlich wollte ich den verschwendeten Raum vor der Schleife nutzen, also fügte ich eine Reihe von Aufzügen hinzu, um den vertikalen Raum dort zu nutzen. Und dann wurde mir klar, dass ich den Code nach der Schleife (siehe vorherige Überarbeitung) unterhalb der Schleife falten konnte , um etwas mehr vertikalen Platz zu nutzen, wodurch fünf weitere Bytes gespart wurden.

Dies ist wahrscheinlich noch lange nicht perfekt, aber es ist eine anständige Verbesserung gegenüber der naiven Lösung, denke ich.

Metagolf

Zeit für etwas Automatisierung ...

Ich habe begonnen, einen Solver in Mathematica einzurichten, um eine optimale Lösung zu finden. Derzeit wird davon ausgegangen, dass die Struktur des Codes fest ist: Zähler auf 12 gesetzt, 4 Zellen zum Drucken, mit der festen Zuordnung zu He,<space>und derselben Reihenfolge dieser Zellen. Was variiert ist die Anzahl der +s in der Schleife sowie die notwendigen Korrekturen danach:

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
 ]

Es stellt sich heraus, dass für einen ersten Zähler von 12 meine handgefertigte Lösung bereits optimal ist. Die Verwendung von 11 spart jedoch zwei Bytes. Ich habe alle Zählerwerte von 6 bis 20 (einschließlich) mit den folgenden Ergebnissen ausprobiert:

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

Hinweis: Bei diesem Solver wird davon ausgegangen, dass sich der lineare Code nach der Schleife in der obersten Zeile befindet und der obige Code die zusammengefaltete Lösung ist. Es könnte eine kürzere Gesamtlösung geben, indem der Löser auf die Faltung aufmerksam gemacht wird, da ich jetzt 3 weitere +s im ersten Teil kostenlos bekomme und die nächsten 4 Anweisungen nur 1 Byte statt 2 kosten würden.

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

Ich werde nur einige Zitate aus der Sprachspezifikation für die Brillanz dieses Esolangs sprechen lassen:

Dark ist eine Sprache, die darauf basiert, ganze Welten und Dimensionen zu manipulieren, um Ziele zu erreichen und die bestmögliche quälende Realität zu schaffen.

Immer wenn ein Syntaxfehler auftritt, verringert sich die Integrität des Programms um 1. [...] Wenn die Integrität des Programms Null erreicht, wird der Interpreter wahnsinnig.

Die Beschädigung kippt ein einzelnes Bit in der Variablen, wenn es auftritt.

Wenn der Master stirbt, sterben auch alle an diesen Master gebundenen Servant-Variablen. Dies ist nützlich für die Gruppierung und Massenvernichtung von Variablen.

Zwingt eine Variable, sich selbst zu töten, und gibt sie frei (denken Sie jedoch daran, dass sie den Zerfall hinterlässt).

Setzt eine Variable auf einen zufälligen Wert. Verwendet den Global Chaos Generator.

Wenn ein Stalker nicht initialisiert wird, führen alle Versuche, E / A auszuführen, dazu, dass Fehlermeldungen gedrückt werden, die in die Konsole geschrieben werden.

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.

Getestet mit dem Ruby-Interpreter. Macht Buchstabensuppe.

Ich habe versucht, so weit wie möglich mit der ursprünglichen Spezifikation übereinzustimmen. Obwohl Sie mit dem von mir verwendeten Interpreter das thes in der Pour contentsAnweisung löschen können, habe ich dies nicht getan.

Die Rührschüssel ist ziemlich teuer, es könnte also einen besseren Ansatz geben. Ich habe versucht, die Nachricht mit der Basiskonvertierung zu codieren, aber leider wird in der Spezifikation nicht klargestellt, ob Divideeine Ganzzahl- oder eine Gleitkommadivision verwendet wird, und der von mir verwendete Interpreter verwendet die letztere. Es gibt auch keinen Modulo-Operator, der auch nicht hilft.

Homespring , 58 Bytes

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

Der nachgestellte Abstand ist erheblich.

Lass mich dir eine Geschichte erzählen. Es gab einmal ein Kraftwerk, das eine nahe gelegene Lachsbrüterei mit Strom versorgte. In der Lachsbrüterei schlüpfte ein junger obdachloser Lachs, der flussaufwärts unterwegs war, um eine Quelle zu finden. Es hat eine solche Quelle gefunden, mit dem poetischen Namen "Hallo Welt!", Wo es gereift ist und einen neuen jungen Lachs hervorgebracht hat. Beide Fische schwammen jetzt stromabwärts auf der Suche nach dem weiten Ozean. Doch kurz vor der Flussmündung befand sich ein Netz im Fluss - der reife Fisch wurde gefangen und nur der junge gelang es, durch den Ozean und den Rest des Universums zu schlüpfen. In der Zwischenzeit hatte die Brüterei mehr Lachse geschlüpft, die ebenfalls flussaufwärts gereist waren und aufgetaucht waren und so weiter und so fort.

Riesige Mengen schmelzenden Schnees waren jedoch über einen anderen Flussarm gefahren. Und gleich nach unserem ersten jungen Lachs aus den Quellen von "Hello, World!" hat den Ozean erreicht, die Schneeschmelze hat das Universum getroffen und ... äh ... es zerstört. Und sie lebten glücklich bis ans Ende ihrer Tage ... oder ich denke, sie haben es nicht getan.

Das war eigentlich die Semantik des obigen Programms. Homespring ist komisch.

Piet, 84 Codels

28x3, hier mit Codelbreite 10 dargestellt.

Erstellt mit PietDev , getestet mit npiet . Das Layout des Programms ist wie folgt:

Gelbe Füllung kennzeichnet Codels, bei denen sich der Pfad überlappt, orange Füllung kennzeichnet Codels, die zum Zwecke des Kontrollflusses dieselbe Farbe haben müssen.

Um dies zu unterstützen, habe ich einen rudimentären Interpreter für eine stapelbasierte Sprache mit piet-ähnlichen Befehlen geschrieben, den ich "pasm" ( Quelle ) getauft habe . Die Ausgabe dieses Interpreters (mit dieser Eingabe ) lautet wie folgt:

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

Es werden keine Zeiger-, Schalter- oder Rollbefehle verwendet. Es werden auch keine Codels verschwendet. Tatsächlich werden zwei wiederverwendet.

Whitespace , 192 150 146 Bytes

Leerzeichen benötigen nur Leerzeichen, Tabulatoren und Zeilenumbrüche, während andere Zeichen ignoriert werden.
Was schwierig sein kann, hier anzuzeigen.
Daher wurden im Code unten die Leerzeichen und Tabulatoren ersetzt.
Und ein ';' wurde der Übersichtlichkeit halber vor die Zeilenvorschübe gestellt.
Ersetzen Sie zuerst, um den Code auszuführen. und> durch Leerzeichen und Tabulatoren.

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

Hexdump des Codes

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

Whitespace-Assemblycode:

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

Bemerkungen:

Ich musste ein Programm schreiben, um zu berechnen, dass das Hinzufügen von 107 das optimale Golf für den Satz ergibt. Da sich die Bytesize ändert, die eine Ganzzahl im Code aufnimmt. : 4 + int (abs (log2 ($ n)))
Der Code wird weiterhin ohne das Label "e:" und den Exit-Teil auf whitespace.kauaveel.ee ausgeführt . Dies könnte jedoch dazu führen, dass der Whitespace-Code auf anderen Whitespace-Compilern ungültig wird. Diese Bytes wurden also nicht aus der Lösung entfernt.

Es ist darauf hinzuweisen, dass

Wie Kevin Cruijssen in den Kommentaren betonte, kann der Whitespace durch Erlauben eines "Exit by Error" gemäß Meta mit mehr als 126 Zeichen golfcodiert werden .

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

Versammlung:

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

In früheren Versionen von Java können Sie möglicherweise einen statischen Block (51 Byte) verwenden, aber ich kenne derzeit keine Möglichkeit, die mainMethode zu umgehen .

CSS, 30 Bytes

:after{content:"Hello, World!"

Cascading Style Sheets (CSS) ist keine typische Programmiersprache, kann aber ziemlich gut feste Ausgaben machen. Dies wird durch die Schaffung eines getan Pseudoelement nach jedem Element mit dem Inhalt Hello, World!. Wenn also nur ein Element ( <html>) ausgewählt ist, wird davon ausgegangen, dass wir das grundlegendste HTML-Dokument verwenden, d. H

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

Dies funktioniert in den meisten gängigen Browsern, mit Ausnahme von Firefox, das den Selektor auf die Elemente <html>und anwendet <body>. Dies ist auch der Grund, warum Stapel-Snippets nicht funktionieren, da immer ein Körperelement mitgestaltet wird. Unten ist eine leicht modifizierte Version zum Testen.

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

HTML, 13 Bytes

Hello, World!

Der Text wird automatisch in das eingefügt <body>und angezeigt.

x86_64-Maschinencode für Linux, 32 Byte

Wenn Linux einen neuen Prozess startet, sind alle Register (mit Ausnahme von RSP) Null, sodass wir RAX = 1 erhalten können, indem wir nur das niedrige Byte ändern. Das x86-64 System V ABI garantiert dies nicht, aber es ist das, was Linux tatsächlich tut. Dieser Code funktioniert nur wie _startin einer statischen ausführbaren Datei.

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

Der Aufrufbefehl schiebt die nächste Adresse, die den Hallo-Welt-String enthält, auf den Stapel. Wir geben die Adresse des Strings ein rsi.

Dann werden die anderen Argumente für a syscallbis eingerichtet sys_write, wodurch die Zeichenfolge gedruckt wird.

Das Programm endet mit einem syscallbis sys_exit. sys_writeGibt die Anzahl der geschriebenen Bytes zurück, sodass die oberen Bytes von RAX nach dem ersten null sind syscall(es sei denn, es wurde ein Fehler zurückgegeben). mov al, 60Geben Sie also RAX = __NR_exitin nur 2 Bytes an.

Sie können dieses Programm zum Segfault machen, indem Sie stdout ( ./a.out >&-) schließen. Es wird also sys_write()zurückgegeben -EBADF, das zweite syscallwird zurückgegeben -ENOSYS, und die Ausführung wird am Ende unterbrochen . Aber wir müssen write()Fehler nicht mit Sorgfalt behandeln.

Hexagony , 37 32 Bytes

Hinweis: Ich werde der ersten Person, die eine gültige Lösung in einem Sechseck der Seitenlänge 3 oder eine nachweislich optimale Lösung der Seitenlänge 4 findet, eine Prämie von 500 Wiederholungen geben. Wenn Sie eine solche Lösung aber nicht finden können Es gelingt mir, meine Punktzahl in einem 4-Sechseck-Feld zu übertreffen (indem ich am Ende des Programms mehr No-Ops bekomme, die im Quellcode weggelassen werden können). Ich bin bereit, auch dafür ein kleineres Kopfgeld auszugeben .

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

Probieren Sie es online!

Ich bin stolz darauf, meine zweite 2D-Programmiersprache und meines Wissens die erste 2D-Sprache auf einem hexagonalen Raster präsentieren zu können.

Der Quellcode sieht nicht sehr 2D aus, oder? Nun, Leerzeichen sind in Hexagony optional. Zunächst wird der Quellcode mit no-ops ( ) zur nächsten zentrierten hexagonalen Zahl aufgefüllt .. Die nächste solche Zahl ist 37, also fügen wir am Ende fünf No-Ops ein. Dann wird der Quellcode in ein reguläres Sechseck umgewandelt:

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

Dies ist auch lauffähig. Probieren Sie es online!

Hexagony verfügt über eine Reihe von interessanten Funktionen, darunter 6 verschiedene Befehlszeiger und ein Speicherlayout, bei dem es sich um das Liniendiagramm eines hexagonalen Gitters handelt. Dieser Code verwendet jedoch nur eine IP-Adresse und eine Speicherkante.

Hier eine Übersicht über die relevanten Befehle:

• Buchstaben setzen nur die aktuelle Speicherflanke auf ihren ASCII-Wert
• ; Gibt den aktuellen Wert (Modulo 256) als Byte an STDOUT aus.
• / ist ein Spiegel, der sich so verhält, wie Sie es erwarten würden (wodurch die IP um 120 Grad gedreht wird).
• Ziffern funktionieren wie im Labyrinth : Sie multiplizieren die aktuelle Zelle mit 10 und addieren sich dann.
• @ Beendet das Programm.

Der letzte Haken ist, dass die Quelle alle drei Kantenpaare umschließt. Wenn die IP das Raster durch eine der sechs Ecken verlässt, gibt es außerdem zwei mögliche Zeilen, zu denen gesprungen werden kann. Welche ausgewählt wird, hängt davon ab, ob der aktuelle Wert positiv oder nicht positiv ist. Die folgende kommentierte Version zeigt, wo die IP-Adresse bei jedem Verlassen des Rasters erneut eingegeben wird:

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

Wenn wir also alle Richtungsänderungen entfernen, läuft dieses Programm auf den folgenden linearen Code hinaus:

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

Was ist mit Q2, P0und P1? Buchstaben lassen sich leicht drucken, da wir die Kante einfach auf den entsprechenden Wert einstellen können. Für das Komma, das Leerzeichen und das Ausrufezeichen funktioniert das nicht. Wir können auch nicht gesetzt nur ihren Wert mit 44, 32, 33bzw. weil die Speicherkante nicht Null ist , mit zu beginnen, und aufgrund der Semantik der einzelnen Ziffern , die alle möglichen verheerenden Schaden anrichten würde. Wenn wir das tun wollten, würden wir den Rand Wert auf Null mit so etwas wie zurückgesetzt haben *, +, -, &oder ^zuerst. Da der Wert jedoch vor dem Ausdruck modulo 256 genommen wird, müssen die Werte nicht exakt auf 44, 32 oder 33 eingestellt werden. Beispielsweise Q2wird der Kantenwert auf gesetzt 81*10 + 2 = 812, d. H44wenn Sie modulo genommen werden 256. Auf diese Weise können wir für jedes dieser drei Zeichen ein Byte speichern. (Leider ist es nie möglich , dass es aus dem Wert mit einer einzelnen Ziffer erhalten die Zelle bereits hat. Komisch, wo es nicht Arbeit ist die oin World, denn das kann auch angefordert werden W9.)

Mit diesem CJam-Skript können Sie alle Buchstaben-Ziffern-Kombinationen suchen, die zu einem bestimmten Zeichen führen.

Ich bin mir nicht sicher, ob das optimal ist. Ich bezweifle, dass dies in einem Sechseck der Seitenlänge 3 möglich ist (wo nur 19 Zeichen verfügbar sind), aber es ist möglicherweise möglich, es in einem Sechseck der Seitenlänge 4 mit weniger als 32 Befehlen, z dass es am Ende des Gitters mehr No-Ops gibt.

Malbolge, 112 Bytes

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

Ich werde sehen, ob es eine kürzere gibt. Ich habe seit dem letzten Mal einen besseren Computer, damit ich einiges schneller generieren kann.

Für die Show, hier ist "Hallo Welt!" ohne Komma.

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

Fourier , 15 Bytes

GROSSE ÄNDERUNGEN zu Fourier!

`Hello, World!`

Probieren Sie es auf FourIDE!

Ja, die Tage der Eingabe des ASCII - Codes der einzelnen Zeichen aus sind für immer verschwunden: Fourier jetzt Art unterstützt Saiten. Wenn Sie einen String in Backticks einschließen, wird dieser String ausgegeben.

Beachten Sie, dass Sie nichts anderes tun können, als diese Zeichenfolge auszugeben: Sie können sie nicht in einer Variablen speichern, sie wird nicht im Akkumulator gespeichert, und es gibt keine Zeichenfolgenmanipulationswerkzeuge.

Hier finden Sie das Zugunglück des alten Fourier. ;)

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

Probieren Sie es online!

Nun, einige von Ihnen werden Fourier wahrscheinlich schon einmal getroffen haben und mit der Sprache ziemlich vertraut sein. Die gesamte Sprache basiert auf einem Akkumulator: einer globalen Variablen, die so gut wie alle Operatoren verwenden.

Der wichtigste Teil des Codes ist der aOperator. Dies nimmt den numerischen Wert des Akkumulators und wandelt ihn unter Verwendung des Python-Codes in ein Zeichen um chr(accumulator). Dies wird dann auf STDOUT gedruckt.

Leider hatte ich noch keine Gelegenheit, Fourier ( Nudge Nudge , Wink Wink ) zu verwenden, hauptsächlich wegen des Fehlens von Strings und String-Operatoren. Trotzdem kann es für viele andere Herausforderungen verwendet werden (siehe den Abschnitt mit Beispielen auf der EsoLangs-Seite).

Beachten Sie, dass dies kürzer ist als mein Eintrag in die Esolangs-Liste, da ich nicht wirklich dachte, dass ich mehr Golf spielen könnte. Und als ich dann die Fourier-Saiten-Golf-Challenge schrieb, wurde mir klar, dass ich einiges kürzer gehen könnte.

Hinweis

Wenn Sie sich über die Variablensyntax wunderten, schrieb Geobits ein Programm, das Variablen verwendet und dieselbe Länge hat:

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

Probieren Sie es online!

C - 155 Bytes

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

Leider wird der einzige bekannte C-- Compiler, Quick C--, nicht mehr gepflegt. Es ist ein Schmerz im Nacken zu bauen, aber es ist möglich ...

C 30 Bytes

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

Ziemlich Vanille, aber ich kann mir keinen allgemein kompilierbaren Weg vorstellen, es kürzer zu machen (es sei denn, vielleicht könnte ein roher asm-Trick funktionieren?). Trotzdem schlägt die meisten Esolangs!

Nicht lesbar , 843 755 732 666 645 629 577 Bytes

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

Nicht lesbare Programme sollen mit einer Schriftart variabler Breite angezeigt werden, sodass sie den Namen der Sprache berücksichtigen. Ich bin ein wenig enttäuscht, dass sich herausgestellt hat, dass meine ausgefeilteren Ansätze viel länger sind. Loops sind unglaublich teuer in Unreadable ...

Probieren Sie es online!

Wie es funktioniert

Unlesbar hat nur zehn Funktionen; Sechs davon werden in diesem Code verwendet:

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

Nach der Verwendung meiner Einzelzeichen-Notation und dem Hinzufügen von Leerzeichen und Kommentaren sieht der obige Code wie folgt aus. Mehrzeilige Anweisungen werden von unten nach oben ausgeführt.

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

Ich habe den eigentlichen Quellcode generiert, indem ich die unkommentierte Version des obigen Pseudocodes über dieses CJam-Programm ausgeführt habe .

Befunge 98 , 19 18 Bytes

Neue Antwort (von undergroundmonorail)

"ck,@!dlroW ,olleH

Erläuterung

• " Startet den String-Modus
• Alles, was folgt, wird auf den Stapel geschoben. Der Stapel ist jetztHello, World!@,kc
• Nachdem der Dolmetscher das Ende erreicht hat, kehrt er zum Anfang zurück
• Es trifft "wieder auf und beendet den String-Modus
• 12 wird auf den Stapel geschoben ( c)
• k Nimmt den obersten Wert von stack und führt den nächsten Befehl aus, den der Befehlszeiger so oft sehen kann
• ,holt einen Wert aus dem Stack und gibt ihn als Zeichen aus. Es wurde 12 Mal durch die letzte kAnweisung ausgeführt und ein weiteres Mal, wenn der Interpreter die ,Anweisung tatsächlich liest
• @ beendet das Programm

Der Unterschied zur alten Antwort besteht darin, dass wir das "Zeichen geschickt wiederverwenden , indem wir Befunges Schleifenverhalten verwenden, wenn es das Zeilenende erreicht. Da es vielleicht weniger intuitiv ist, lasse ich auch das alte. Möglicherweise haben Sie auch bemerkt, dass der Stapel ck,@aufgrund dieses netten Tricks noch einige Zeichen ( ) enthält , was zu Verwirrung führt, wenn wir danach jemals etwas tun wollten.

Alte Antwort

"!dlroW ,olleH"ck,@

Dies funktioniert für Funge und Befunge 98

Erläuterung

• Alles dazwischen ""wird auf den Stapel geschoben. ( 'H'ist jetzt oben.)
• c (12) wird auf den Stapel geschoben
• k Nimmt den obersten Wert von stack und führt den nächsten Befehl aus, den der Befehlszeiger so oft sehen kann.
• ,holt einen Wert aus dem Stack und gibt ihn als Zeichen aus. Es wurde 12 Mal durch die letzte kAnweisung ausgeführt und ein weiteres Mal, wenn der Interpreter die ,Anweisung tatsächlich liest
• @ beendet das Programm

JSFuck , 6293 6289 6277 Bytes

Dies wird möglicherweise als eines der längsten "kürzesten Hello, World! -Programme" erwähnt (eigentlich weiß ich nicht, ob dies optimal ist, aber es ist das kürzeste, das ich bekommen habe).

Achtung: Funktioniert nur in Firefox und Safari

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

Es gibt auch eine etwas längere Version (+4 Byte), die auch in Chrome und Microsoft Edge funktioniert:

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

Für diejenigen, die mit JSFuck nicht vertraut sind, geht es darum, JavaScript so zu schreiben, als gäbe es nur sechs Zeichen, und es kann manchmal ziemlich verrückt werden.

Diese Tabelle zeigt, wie die in Hello, World! Programm sind in JSFuck codiert. Der Klartextcode ist einfachalert("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                 |
+----------+--------------------------------------+---------------------------+

Hier die Saiten "fill","fontcolor" usw. müssen geschrieben werden "f"+"i"+"l"+"l", "f"+"o"+"n"+"t"+"c"+"o"+"l"+"o"+"r"zu codieren.

Die globalen Bezeichner self,atob wie btoafolgt geschrieben Function("return self")().

Functionselbst sollte sein []["fill"]["constructor"].

Das Komma ","ist schwierig, ich bin nicht 100% sicher, wie es funktioniert, aber es verwendet die[]["concat"] Funktion, um ein Array zu erstellen. Ich werde ein Update veröffentlichen, wenn ich Zeit habe, weitere Tests durchzuführen.

Ich habe dies mit JScrewIt - Credits für GOTO 0 kodiert , um ein so ausgeklügeltes Tool zu erstellen:

• Öffnen Sie Firefox (Sie können einen oder mehrere andere Browser auswählen, aber der kürzeste Code ist nur Firefox.)
• Navigieren Sie zu JScrewIt : http://jscrew.it
• Eingang: alert("Hello, World!")
• Ausführbarer Code: überprüft
• Kompatibilität: Nur dieser Browser

Dies unterscheidet sich von meiner Antwort auf diese Frage für das Vorhandensein des Kommas nach "Hallo".

Interessanterweise ist die ES6-Syntax

alert`Hello, World!`

Die Codierung nimmt noch mehr Bytes in Anspruch (etwa +1500), da die Codierung von zwei Backticks und nicht von ("und komplexer ist ").

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

Ich glaube, dies ist optimal für ein lineares Programm (dh eines, das die Kontrollflussoperatoren ?und nicht verwendet)* ). Es mag insgesamt optimal sein, aber ich weiß nicht, wie ich diese zusätzlichen Operatoren in einer so kleinen Menge Code verwenden soll (oder wie ich die Möglichkeiten programmgesteuert ausloten soll).

Die Sprache hat kürzlich einige Änderungen erfahren, nachdem ich mit dem Autor per E-Mail darüber gesprochen habe. Allerdings habe ich eine Referenzimplementierung geschrieben für den aktuellen Zustand der Sprache spec letzte Woche, so dass der obige Code tatsächlich runnable ist.

Metagolf

Ursprünglich hatte ich die Ausgabe meiner Referenzimplementierung für diese Herausforderung verwendet und daraus eine handgefertigte Lösung erstellt. Dies war jedoch nur ein heuristischer Ansatz.

Stattdessen habe ich einen Solver in Mathematica geschrieben, der die Pada-Datenstrukturen und -Operatoren kennt, um eine optimale Lösung zu finden. Im Durchschnitt wächst es linear mit der Länge der Zeichenfolge (obwohl einige Zeichenkombinationen etwas langsamer sind als andere) und dauerte etwa 1,5 StundenHello, World! .

Wie habe ich den Solver geschrieben? Zunächst stellen wir fest, dass wir nur 6 Operatoren berücksichtigen müssen: ~.oOqQ(zuzüglich der wfür jedes der gedruckten Zeichen erforderlichen ). Das Verwenden der Stapel oder der Bit-Sperren ist im linearen Code nicht nützlich, und ich glaube nicht, dass ?und *effektiv in weniger als 68 Bytes verwendet werden kann.

Padas Status (ohne Berücksichtigung der Stapel und Sperren) besteht aus 7 Schaltern und 8 Bits, die wie folgt angeordnet sind:

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

So das ist 215 = 32768 mögliche Zustände. Mein erster Vorverarbeitungsschritt war die Erstellung eines gerichteten Zustandsgraphen, bei dem jede Kante einer einzelnen Operation entspricht. Das heißt, der Graph hat 32768 Scheitelpunkte mit jeweils 6 Out-Graden (eine Out-Flanke für jede der 6 betrachteten Operationen). Wir können dieses Diagramm verwenden, um den kürzesten Weg zwischen zwei Zuständen zu finden (dieses Diagramm allein kann für das Golfen von Pada sehr nützlich sein).

Nun wollen wir für jedes Zeichen einen Zustand erreichen, in dem wdieses Zeichen gedruckt wird. Wie viele solcher Staaten gibt es? wLiest das Byte von dem Bit, auf dem es abgelegt wurde (zyklisch). Es gibt also 8 mögliche Rotationen der Bits des Zeichens, die alle dieses Zeichen drucken können. Für jede dieser Umdrehungen sind drei Schalter fixiert (um ein wAbsenken in die richtige Position zu ermöglichen). Dies lässt 4 beliebige Schalter. Wir haben also mögliche Zustände für jeden in unserem Code.8 * 24 = 128w

Mit diesen können wir ein anderes Graphproblem lösen: Konstruieren Sie einen Graphen, der einen Quellscheitelpunkt, dann eine "Ebene" für jedes Zeichen und einen Senkscheitelpunkt hat. Die Schichten bestehen aus den 128 Zuständen für jeden Scheitelpunkt, der Quellknoten entspricht dem Anfangszustand des Programms (alle Schalter nach links und alle Bits sind Null). Der Senkenknoten entspricht insbesondere keinem Zustand. Wir haben Kanten von jedem Scheitelpunkt in einer Ebene zu jedem Scheitelpunkt in der nächsten Ebene gerichtet, wobei das Kantengewicht der Abstand zwischen den beiden Zuständen in unserem vorherigen Diagramm ist. Die Kantengewichte von der letzten Schicht bis zum Waschbecken sind alle 0. Das heißt, wir können alle diese Kantengewichte vorberechnen. Dies ist der teuerste Schritt der Berechnung und dauerte 1,5 Stunden Hello, World!.

Mit diesem Diagramm können wir den kürzesten Weg von der Quelle zur Senke ziemlich schnell finden (es dauerte 0,05 Sekunden auf meinem Computer). Für Hello, World!die gewünschten Zustände sind:

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

Dabei entsprechen die niedrigstwertigen 7 Bits den Schaltern und die höchstwertigen 8 Bits den Pada-Bits.

Jetzt kehren wir zum ersten Graphen zurück und finden die tatsächlichen Kanten (dh Operationen), die dem kürzesten Pfad zwischen jedem Paar nachfolgender Zustände entsprechen, und beenden jeden von ihnen mit einem w. Voilà, eine optimale Lösung (basierend auf den obigen Annahmen).

Hier ist die vollständige Mathematica, falls jemand jemals eine andere Saite in Pada metagolfing möchte:

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]) <> ""