Comme certains d'entre vous le savent peut-être, pour obtenir une langue sur le merveilleux Try It Online de Dennis ! , un bonjour, le monde! programme est requis. Récemment, Dennis a proposé un moyen de charger ces programmes à partir du site Web. Voici une corbeille JSON des caractères utilisés dans ces programmes, par fréquence, au 27 juillet 2017.

Certains de ces personnages ont besoin d'amour, donc votre défi est de produire Hello, World! (de préférence dans une langue impliquée dans ce processus), en utilisant uniquement les caractères spécifiés ci-dessous. Ces personnages sont tous les caractères utilisés entre 10et 99(inclusivement), avec les deux personnages les plus courants, 0et parce que je me sens bien.

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

Votre utilisation du caractère doit être basée sur son apparence dans un programme normal, et non sur son point de code ou sa valeur d'octet.

Vous devez utiliser au moins un caractère de cet ensemble, donc les programmes de longueur 0 ne sont pas valides.

C'est le code-golf , donc la réponse la plus courte en octets l'emporte.

JSFiddle pour vérifier si votre réponse est valide

SOGL V0.12 , 89 75 68 octets

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

Essayez-le ici!
Remarque: chaque fois que la qsortie est référencée ici, elle ne oOpPs'affiche pas car la sortie popping (aucune ) n'est indisponible ou génère une nouvelle ligne pré-ajoutée.

Explication (obsolète, ce qui a changé, c'est que le "H" est imprimé en utilisant les lettres de l'alphabet):

 $             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

Fait amusant: tous les caractères des caractères autorisés sont dans la page de code SOGL: D

Perl 5 , 76 octets

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

Cela utilise une fonctionnalité qui est obsolète, mais qui fonctionne localement dans mon terminal (qui est la version 5.18.2 comme indiqué). Dans les anciennes versions de Perl ?\w?est un synonyme /\w/qui me donne accès à la correspondance d'expressions rationnelles et j'ai suffisamment de caractères pour $&(dernière correspondance) et $`(texte précédant la dernière correspondance). J'en ai besoin pour pouvoir obtenir le O. Je génère cela en créant une globréférence ( $_=\*Gqui, exprimée en scalaire, ressemble à quelque choseGLOB(0x7ffb728028d0) ). Une fois que c'est dedans $_, ?B?correspondra à Bet $`contiendra GLO, je pourrai alors faire correspondre \w$ce qui serait stocké Odans$&qui est inséré dans les chaînes que j'exécute chaîne par chaîne-ET pour créer le reste du texte, le corps de la chaîne est en minuscules à l'aide \L.

Essayez-le en ligne! - utilise /\w/à la place ?\w?car la version de Perl sur TIO est trop récente.

Perl 5 , 65 octets

C'est un peu plus tricheur car il s'appuie sur le nom de fichier sur TIO (qui est .code.tio), donc je ne pense pas vraiment que ce soit en compétition, mais j'étais content du résultat!

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

Essayez-le en ligne!

Unaire , 7 * 10 ¹⁸² octets

Unary est Brainfuck converti en binaire converti en unaire en utilisant 0comme compteur. Essentiellement, il condense un programme Brainfuck en un nombre et la sortie est ce nombre de 0s. Ce sont généralement de très gros programmes.

Je ne collerai pas le programme ici parce que je ne sais pas combien de texte SE permet mais je parie que c'est moins que cela. Au lieu de cela, je vais coller le nombre précis de zéros dans cette réponse:

708184005756841022918598670049178934705323143517361395031673227349803938380119378597780037353721967636097362645175347036417214959141923667629285233360306016978751166690464736541968556

Comme c'est une réponse assez bon marché, garantie de ne pas être la plus courte, et je l'ai simplement copiée , je fais de ceci un article wiki.

05AB1E , 137 106 95 octets

X00X00DXX00DXX00XX0X0X00D0XXXX0X00X00XXX00XXX0XXXXXX00XXXXX0XXXX00D0X000DD00XXJC000gDD0000g***B

Essayez-le en ligne!

-31 merci à @Adnan d'avoir indiqué que je pouvais utiliser la base 108.

- ?? merci à @Riley d'avoir signalé des erreurs.

Ancienne version (méthode différente):

05AB1E , 211 186 166 octets

0g00g000000000gUX000000gXX00000g000g00g000gD0000g0 000g00000gX00000gX00000g0 00000g00000000g0000000g00g00000000gD000000gX0000000g0g00000gUXJX00000000000000000g000g**B

Essayez-le en ligne!

Haha! ET ICI JE NE PENSE PAS ESOLANGS STOOD AUCUNE CHANCE PLAUSIBLE!

Nous obtenons d'abord 255 stockés dans X:

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

Ensuite, en utilisant la même astuce de longueur, nous poussons: 1296995323340359595058728869715

0g00g000000000g000000g000000000g000000000g00000g000g00g000g000g0000g0 000g00000g000000000g00000g000000000g00000g0 00000g00000000g0000000g00g00000000g00000000g000000g000000000g0000000g0g00000gJ

Où nous utilisons simplement à la 0<space>place de la longueur pour les zéros.

Puis, enfin, nous poussons les 255 que nous avons stockés et convertissons de 255 en base 10 :

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

Toujours jouer au golf en utilisant les autres caractères autorisés et la duplication, ce sera une minute.

Beatnik , 148 octets

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

Essayez-le en ligne!

Explication

Beatnik fonde l'instruction exécutée sur la base du score de scrabble du mot. Voici une explication abrégée:

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

Poules d'eau (v2.0), 3423 983 923 866 749 716 octets

Je pense que cela peut être un peu joué au golf, Moorhens n'est pas une langue facile à travailler.

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

Explication

Moorhens est une langue basée sur des mots du dictionnaire. Chaque mot correspond à une opération basée sur son hachage. Les cinq opérations utilisées ici sont xU, ER, XI, KAetAA

• xU incrémente le TOS
• ER met un nouveau zéro sur la pile.
• XI décrémente le TOS
• KA duplique le TOS
• AA roule le TOS vers le bas

Nous poussons chaque lettre avec des applications successives de ces opérations.

Glypho , 480 octets

AABCABABABBAABABAABCABBAABABABBCABBAABABABABABABABBAABBAABABABABABABABBAABBAAABCABBAABABAABCAABCABBAABABABBCABABABBAABBAABABAABCAABCABBAAABCABBAABABABBAABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABAAABABAABAABBAABCAABABABBAABBAAABCAABCABBAABABABBCABABABBCABABABBAABAAABABAABAABABABBAABABABBAABABABAAABABAABAABBAABABABBAAABCABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABCAABAAABABAABAABBAABABABBCAABCABBAAABCAABCABBAAABCABBAABABABBAABABABBCABABABBAABAAABABABCAABBAAABAABACABBBABCB

Essayez-le en ligne!

Headsecks , 78 octets

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

Double JavaScript, 318 octets

Je ne sais pas si c'est autorisé, je n'ai pas pu le faire en utilisant l'interpréteur JavaScript une fois. Il est similaire à utiliser, eval()mais j'utilise à la place l'interpréteur deux fois: (Essayez-le dans la console pour obtenir le résultat imprimé)

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

Essayez-le en ligne!

Évalue à:

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

Essayez-le en ligne!

Qui évalue à Hello, World!

Smallf ** k , 266 octets:

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

En fait, les personnages sont un peu hors de propos. C'est juste une question de savoir si chaque personnage a ou non un point de code pair ou un point de code impair. Ainsi, j'ai fait un effort pour utiliser tous les caractères disponibles (sauf les caractères multi-octets) (bien que comme il a été randomisé, je n'ai pas fait d'effort pour le garantir).

Pyke , 133 144 octets

? 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

Essayez-le en ligne!

Un horrible gâchis de code qui peut presque certainement être raccourci ... Le construit un caractère à la fois.

? 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!"

dc , 164 162 octets

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

Essayez-le en ligne!

Il y a probablement une approche meilleure / plus intéressante. J'ai essayé d'utiliser l'astuce ASCII + 256 qui dca, mais qui génère également des caractères supplémentaires (même s'ils ne sont pas en cours d'impression), et une fois arrivé à `` o '', le 111 merveilleusement premier, j'ai eu du mal à obtenir un valeur de 111+ (multiple de 256) qui a pris en compte proprement. Voici donc une solution assez simple (bien que jouée au golf si possible):

Dans dc, zest une commande qui pousse la profondeur de pile sur la pile. Cela signifie que nous pouvons l'utiliser comme incrément. C'est ainsi que je crée la plupart de mes valeurs ASCII pour ce défi (imprimé avec P), que je pousse sur les piles nommées avec Set remonte sur la pile principale avec L.

dcvous permet d'utiliser les valeurs hexadécimales AF même lorsque le radix d'entrée est décimal (par défaut). Heureusement, notre première lettre, 72, est un multiple de 12, donc j'économise un octet ou deux ici en multipliant 6 * 12 et en imprimant immédiatement ( zzzzzzzC*P). Ma version de 164 octets a utilisé la multiplication dès le début pour obtenir 72 ('H'), ce qui était légèrement intelligent, mais un maintien d'une tentative précédente et un gaspillage d'octets. Maintenant, je commence par incrémenter et enregistrer l'espace, le point d'exclamation et la virgule, qui sont hors service et ne peuvent donc pas encore être imprimés. Ensuite, j'arrive au «H», que j'imprime immédiatement, avant d'arriver au «W», que je dois conserver pour plus tard.

J'imprime simplement lorsque je frappe le «e», puis j'augmente jusqu'à «l». J'en imprime deux et j'en sauvegarde une. Quand je fais à « o », j'ai pensé que je devais sauver un de ceux pour plus tard, mais tout est genre de pour à ce stade. J'imprime un «o», récupère ma virgule, mon espace et mon «W» de tout à l'heure, et maintenant je reviens à «o». J'imprime ceci et j'en incrémente quelques-uns jusqu'à la valeur nécessaire la plus élevée, «r» (114), que j'imprime avant de charger et d'imprimer le «l» que j'ai replié plus tôt.

Presque fini! 'd' est la valeur ASCII 100, qui se fait facilement en multipliant 10 * 10 (moins d'octets que de l'avoir stocké plus tôt et de le charger maintenant). La valeur hexadécimale Aest de 10, tout comme notre base d'entrée que nous pouvons récupérer avec la commande I. Multipliez-les, imprimez, puis chargez et imprimez notre point d'exclamation antérieur. Bonjour le monde!