Wie einige von Ihnen vielleicht wissen, um eine Sprache für Dennis 'wundervollen Online-Test zu bekommen ! , ein Hallo, Welt! Programm ist erforderlich. Vor kurzem hat Dennis einen Weg gefunden, diese Programme von der Website zu laden. Hier ist ein JSON- Pastebin der in diesen Programmen verwendeten Zeichen nach Häufigkeit, Stand 27. Juli 2017.

Einige dieser Charaktere brauchen etwas Liebe, daher besteht Ihre Herausforderung darin, Hello, World! (vorzugsweise in einer Sprache, die an diesem Prozess beteiligt ist), wobei nur die unten angegebenen Zeichen verwendet werden. Diese Zeichen sind alle Zeichen, die zwischen 10und 99(einschließlich) verwendet werden, zusammen mit den beiden häufigsten Zeichen 0und , weil ich mich gut fühle.

0 $&*?ABCDEFGIJKLNPQRSTUXYZ\`gjkqwxyz{}÷≤≥=║_

Ihre Verwendung des Zeichens sollte auf seinem Erscheinungsbild in einem normalen Programm basieren, nicht auf seinem Codepunkt oder Bytewert.

Sie müssen mindestens ein Zeichen aus diesem Satz verwenden, damit Programme der Länge 0 ungültig sind.

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

JSFiddle, um zu überprüfen, ob Ihre Antwort gültig ist

SOGL V0.12 , 89 75 68 Bytes

z{}xxxx≥x≥x≥xXUqXxq≤qq≤q *R_IIRq  q *R_I0II*IRqxXq≤qxqxq CR_0II÷Rq0*

Probieren Sie es hier aus!
Hinweis: Wenn hier auf qoder Ausgabe Bezug genommen wird, wird diese nicht oOpPangezeigt, da keine (n) Popping-Ausgaben verfügbar sind oder eine vorangestellte neue Zeile ausgegeben wird.

Erklärung (veraltet, was sich geändert hat, ist, dass das "H" mit den Buchstaben gedruckt wird):

 $             push "$"
  R_           convert to an array of ordinals, then push all the contents to the stack
    0II        push 0+1+1 = 2
       *       multiply by that
        R      convert to character
         q     output
          z    push the lowercase alphabet
           {}  iterate over it, pushing each char, and do nothing. Stack: ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
stack manipulation:
 xxxx ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r"]
 ≥    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q"]
 x    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o"]
 ≥    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n"]
 x    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l"]
 ≥    ["l","o","r","H","a","b","c","d","e","f","g","h","i","j","k"]
 xxx  ["l","o","r","H","a","b","c","d","e"]
 q    output the "e"
 ≤    ["o","r","H","a","b","c","d","e","l"]
 qq   output the "l" twice
 ≤    ["r","H","a","b","c","d","e","l","o"]
 q    output the "o"

*                       push "*",
 R_                     convert to an array of ordinals, then push all to stack
   II                   increase by 2
     R                  convert back to character
      q                 output
         q              push a space, then output
           *            push "*"
            R_          convert to an array of ordinals, then push all to stack
              I         increase that
               0II      push 0+1+1 = 2
                  *     multiply
                   I    increase
                    Rq  output as character
stack manipulation: (starting stack: ["r","H","a","b","c","d","e","l","o",","," ","W"])
 x  ["r","H","a","b","c","d","e","l","o",","]
 X  ["r","H","a","b","c","d","e","l","o"]
 q  output the "o"
 ≤  ["H","a","b","c","d","e","l","o","r"]
 q  output the "r"
 x  ["H","a","b","c","d","e","l"]
 q  output the "l"
 x  ["H","a","b","c","d"]
 q  output the "d"

C            push "C"
 R_          convert to ordinal as before
   0II÷      floor divide by 2
       Rq    output as character
         0*  multiply by 0 so nothing extra would be outputted

Unterhaltsame Tatsache: Alle Zeichen der zulässigen Zeichen sind in der SOGL-Codepage enthalten: D

Perl 5 , 76 Bytes

}{${$_=$`x?B?}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}=$_=\*G

Dies verwendet eine Funktion, die veraltet ist, aber lokal in meinem Terminal funktioniert (Version 5.18.2, wie angegeben). In älteren Versionen von Perl ?\w?ist dies ein Synonym, für /\w/das ich Zugriff auf reguläre Ausdrücke habe und über genügend Zeichen für $&(letzte Übereinstimmung) und $`(Text vor der letzten Übereinstimmung) verfüge . Ich brauche diese, um die zu bekommen O. I erzeugt dies einen erschaffen globReferenz ( $_=\*Gdie, auf einen Skalar gegossen ist so etwas wieGLOB(0x7ffb728028d0) ). Sobald das in ist $_, ?B?wird das Spiel Bund $`enthält GLO, kann ich dann gegen entsprechen \w$denen würde speichern Oin$&Dies wird in die Zeichenfolgen eingefügt, die ich im Zeichenfolgen-UND-Modus ausführe, um den Rest des Texts zu erstellen. Der Textkörper der Zeichenfolge wird mit Groß- und Kleinschreibung dargestellt \L.

Probieren Sie es online! - Wird /\w/anstelle von verwendet, ?\w?da die Version von Perl unter TIO zu neu ist.

Perl 5 , 65 Bytes

Dies ist ein bisschen betrügerischer, da es sich auf den Dateinamen von TIO (das ist .code.tio) stützt , also denke ich nicht wirklich, dass dies konkurriert, aber ich war mit dem Ergebnis zufrieden!

}{${$_=$0}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}

Probieren Sie es online!

Unär , 7 * 10 ¹⁸² Bytes

Unary wird von Brainfuck in Binary konvertiert, wobei Unary 0als Zähler verwendet wird. Im Wesentlichen verdichtet es ein Brainfuck-Programm in eine Zahl und die Ausgabe ist diese Zahl von 0s. Es sind normalerweise sehr große Programme.

Ich werde das Programm hier nicht einfügen, da ich nicht weiß, wie viel Text SE zulässt, aber ich wette, es ist weniger als dies. Stattdessen füge ich die genaue Anzahl der Nullen in diese Antwort ein:

708184005756841022918598670049178934705323143517361395031673227349803938380119378597780037353721967636097362645175347036417214959141923667629285233360306016978751166690464736541968556

Da dies eine ziemlich billige Antwort ist, die garantiert nicht die kürzeste ist, und ich sie einfach kopiert habe, mache ich dies zu einem Wiki-Beitrag.

05AB1E , 137 106 95 Bytes

X00X00DXX00DXX00XX0X0X00D0XXXX0X00X00XXX00XXX0XXXXXX00XXXXX0XXXX00D0X000DD00XXJC000gDD0000g***B

Probieren Sie es online!

-31 Dank an @Adnan für den Hinweis, dass ich die Basis 108 verwenden könnte.

- ?? Vielen Dank an @Riley für den Hinweis auf einige Fehler.

Alte Version (andere Methode):

05AB1E , 211 186 166 Bytes

0g00g000000000gUX000000gXX00000g000g00g000gD0000g0 000g00000gX00000gX00000g0 00000g00000000g0000000g00g00000000gD000000gX0000000g0g00000gUXJX00000000000000000g000g**B

Probieren Sie es online!

Haha! Und hier dachte ich ESOLANGS HABEN KEINE GLAUBLICHE CHANCE!

Zuerst werden 255 in X gespeichert:

00g               # Push 2 (length of 00).
   00000g         # Push 5 (length of 00000).
         00000g   # Push 5.
               JU # Join to 255 and store in X.

Dann drücken wir mit dem gleichen Längen-Trick: 1296995323340359595058728869715

0g00g000000000g000000g000000000g000000000g00000g000g00g000g000g0000g0 000g00000g000000000g00000g000000000g00000g0 00000g00000000g0000000g00g00000000g00000000g000000g000000000g0000000g0g00000gJ

Wobei wir 0<space>anstelle des Längentricks nur die Nullen verwenden.

Dann schieben wir endlich die 255, die wir gespeichert haben, und konvertieren von 255 zu Basis 10 :

X  # Push stored 255.
 B # Convert to base 255.

Das Golfen mit den anderen erlaubten Zeichen und die Vervielfältigung werden eine Minute dauern.

Beatnik , 148 Bytes

K QQQQQQQG ZD XA K QQJA KD ZD XA K KG KD ZD ZD ZD XA XA K B KD ZD XA K QQQQF ZD ZD XA K QQQD XA K A Z KD XA ZD XA K B KD XA ZD XA K J Z XA K QQQB XA

Probieren Sie es online!

Erläuterung

Beatnik stützt den ausgeführten Befehl auf den Scrabble-Score des Wortes. Hier ist eine verkürzte Erklärung:

Code         Scrabble Score   Explanation

K            5                push the scrabble score of the next word
QQQQQQQG     72               72 ['H']
ZD           12               pop a value; push it back twice
XA           9                pop a value; print its ASCII character
KD           7                pop two values; push their sum
Z            10               pop two values; push their difference

Moorhens (v2.0), 3423 983 923 866 749 716 Bytes

Ich denke, man kann ein bisschen Golf spielen, Moorhens ist keine einfache Sprache, mit der man arbeiten kann.

xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU KA AA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU KA KA xU xU xU AA AA AA AA AA KA xU AA KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU KA XI XI XI XI XI XI KA XI XI XI XI XI XI XI XI AA AA AA AA AA AA AA AA AA AA AA AA

Erläuterung

Moorhens ist eine Sprache, die aus Wörterbuchwörtern besteht. Jedes Wort entspricht einer Operation, die auf ihrem Hash basiert. Die fünf Operationen hier verwendet werden , sind xU, ER, XI, KA, undAA

• xU erhöht die TOS
• ER legt eine neue Null auf den Stapel.
• XI dekrementiert die AGB
• KA dupliziert die AGB
• AA rollt die TOS nach unten

Wir treiben jeden Brief mit sukzessiven Anwendungen dieser Operationen voran.

Glypho , 480 Bytes

AABCABABABBAABABAABCABBAABABABBCABBAABABABABABABABBAABBAABABABABABABABBAABBAAABCABBAABABAABCAABCABBAABABABBCABABABBAABBAABABAABCAABCABBAAABCABBAABABABBAABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABAAABABAABAABBAABCAABABABBAABBAAABCAABCABBAABABABBCABABABBCABABABBAABAAABABAABAABABABBAABABABBAABABABAAABABAABAABBAABABABBAAABCABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABCAABAAABABAABAABBAABABABBCAABCABBAAABCAABCABBAAABCABBAABABABBAABABABBCABABABBAABAAABABABCAABBAAABAABACABBBABCB

Probieren Sie es online!

Headsecks , 78 Bytes

yyzyzzxNxNzx{yyy{y{y{yzzz_{_zzyy\zxxxxxx\zzy\\zz\zx\{{\{{\zzz\xxx\{{\{{y\zzzx\

Double JavaScript, 318 Bytes

Ich bin mir nicht sicher, ob das erlaubt ist. Ich konnte es nicht einmal mit dem JavaScript-Interpreter machen. Es ist ähnlich zu benutzen, eval()aber stattdessen benutze ich den Interpreter zweimal: (Versuchen Sie es in der Konsole, um das Ergebnis wieder auszudrucken)

`\`\\x${0xA*0xA&0xC}${0xA&0xC}\\x${0xA*0xF&0xF}${0xB*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}F\\x${0xE*0xF&0xF}C\\x${0xE*0xF&0xF}${0}\\x${0xB*0xF&0xF}${0xB*0xB*0xF&0xF}\\x${0xA*0xF&0xF}F\\x${0xB*0xB*0xF&0xF}${0xE*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}${0xA*0xA&0xC}\\x${0xE*0xF&0xF}${0**0}\``

Probieren Sie es online!

Bewertet zu:

`\x48\x65\x6C\x6C\x6F\x2C\x20\x57\x6F\x72\x6C\x64\x21`

Probieren Sie es online!

Welches bewertet zu Hello, World!

Smallf ** k , 266 Bytes:

zJ$NJ`ZZx*gQYQQ{zqyKKUkUR?AS`zB`JB&UCKCIxQ_G0*000FzzJ&?YwkC\qqgZ`xYQyC}DgY_&_S}KPZ\&?SGAE&{Gw_w} GAgA{qT{gC&`qI?xwCNQwgR}?{*QEwQUj&BT&jR__IJJIqUqAPF0yICXESL?AYR QIAFU& yYwE&$\Njj B0T*F j$?kCzQk*}U}UgI$}Ew_yDL`qYI*E_G}SCjXDFNJKGNIGyIwA\BzLP`*zCILGCNqyYZyq? GwN{q{gKSj

Eigentlich sind die Charaktere irgendwie irrelevant. Es ist nur eine Frage, ob jedes Zeichen einen geraden oder einen ungeraden Codepunkt hat. Daher habe ich mich bemüht, alle verfügbaren Zeichen (mit Ausnahme der Multibyte-Zeichen) zu verwenden (obwohl ich mich nicht bemüht habe, dies zu garantieren, da es zufällig war).

Pyke , 133 144 Bytes

? BXKKKKRKRKRK\CkJ00q}}}XEjTX}G_E\E\L\LkJjRT}}XRGREkJjR 00q}R? B_RE\ \wkJjRT}}XRGRE\R\L\DkJjRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJjRT}}RG_RE00q}}RAA

Probieren Sie es online!

Eine schreckliche Codeverwirrung, die mit ziemlicher Sicherheit verkürzt werden kann ... Erstellt jeweils ein Zeichen.

? BXKKKKRKRKRK\CkJ - ".C" - A string that when evaled, gets the character at the point
00q}}}XEj - Construct 64 by doing `((0==0)*2*2*2)**2` and then eval, getting the "@" character and store it in `j`
TX}G_E - Get "h" using `@` by looking it up in the alphabet
\E\L\LkJ - "hELL"
jRT}}XRGREkJ - "hELLo"
jR 00q}R? B_RE  - ","
\ \wkJ - "hELLo, w"
jRT}}XRGRE\R\L\DkJ - "hELLo, woRLD"
jRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJ - "hELLo, woRLD!"
jRT}}RG_RE00q}}RAA - "Hello, World!"

Gleichstrom , 164 162 Bytes

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzS zzS?zzzzzzzzzzzzS$zzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzzzzzzzzzzzzzzzSwzzzzzzzzzzzzzzzPzzzzzzzzSLzPzPzzzzPL$PL PLwPzPzzzzPLLPAI*PL?P

Probieren Sie es online!

Es gibt wahrscheinlich einen besseren / interessanteren Ansatz. Ich habe versucht, den ASCII + 256-Trick zu verwenden, dcder aber auch zusätzliche Zeichen ausgibt (auch wenn sie nicht gedruckt werden), und als ich das 'o' bekam, die wunderbare Primzahl 111, bekam ich sogar ein Problem Wert von 111+ (Vielfaches von 256), der sauber berücksichtigt wurde. Hier ist also eine recht einfache (wenn auch wenn möglich Golf) Lösung:

In dc, zist ein Befehl, der die Stapeltiefe auf den Stapel schiebt. Das heißt, wir können es als Inkrement verwenden. Auf diese Weise erstelle ich die meisten meiner ASCII-Werte für diese Herausforderung (gedruckt mit P), die ich auf benannte Stapel mit schiebe Sund mit auf den Hauptstapel zurückspringe L.

dcMit dieser Option können Sie die Hexadezimalwerte AF auch dann verwenden, wenn der Eingaberadix dezimal ist (Standardeinstellung). Zum Glück ist unser erster Buchstabe 72 ein Vielfaches von 12, daher spare ich hier ein oder zwei Bytes, indem ich 6 * 12 multipliziere und sofort drucke ( zzzzzzzC*P). Meine 164-Byte-Version verwendete die Multiplikation von Anfang an, um 72 ('H') zu erhalten, was ein wenig clever war, aber ein Überbleibsel aus einem früheren Versuch und eine Verschwendung von Bytes. Jetzt erhöhe und speichere ich zunächst den Speicherplatz, das Ausrufezeichen und das Komma, die nicht in Ordnung sind und daher noch nicht gedruckt werden können. Als nächstes komme ich zum "H", das ich sofort drucke, bevor ich zum "W" komme, das ich für später speichern muss.

Ich drucke einfach, wenn ich das 'e' drücke, und erhöhe mich dann auf 'l'. Ich drucke zwei davon und speichere eine. Als ich es ‚o‘ mache, dachte ich zuerst würde ich einen von denen zu sparen habe später, aber alles ist Art an dieser Stelle um. Ich drucke ein 'o', rufe mein Komma, Leerzeichen und 'W' von früher ab und bin jetzt gleich wieder bei 'o'. Ich drucke dies aus und inkrementiere einige bis zum höchstmöglichen Wert, 'r' (114), den ich drucke, bevor ich das 'l', das ich zuvor verstaut habe, lade und drucke.

Fast fertig! 'd' ist der ASCII-Wert 100, der einfach durch Multiplizieren von 10 * 10 (weniger Bytes als zuvor gespeichert und jetzt geladen) erstellt wird. Der Hex-Wert Aist 10, ebenso wie unser Eingaberadix, den wir mit dem Befehl abrufen können I. Multiplizieren Sie diese, drucken Sie und laden und drucken Sie dann unser früheres Ausrufezeichen. Hallo Welt!