Como algunos de ustedes saben, para obtener un idioma en el maravilloso ¡ Pruébelo en línea de Dennis ! , un Hola Mundo! Se requiere programa. Recientemente, Dennis abrió una forma de cargar estos programas desde el sitio web. Aquí hay una combinación JSON de los caracteres utilizados en esos programas, por frecuencia, a partir del 27 de julio de 2017.

Algunos de esos personajes necesitan un poco de amor, por lo que su desafío es generar Hello, World! (preferiblemente en un idioma involucrado en este proceso), utilizando solo los caracteres especificados a continuación. Estos personajes son todos los personajes utilizados entre 10e 99(inclusive) veces, junto con los dos personajes más comunes 0y , porque me siento bien.

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

Su uso del personaje debe basarse en su apariencia en un programa normal, no en su punto de código o valor de byte.

Debe usar al menos un carácter de ese conjunto, por lo que los programas de longitud 0 no son válidos.

Este es el código de golf , por lo que la respuesta más corta en bytes gana.

JSFiddle para verificar si su respuesta es válida

SOGL V0.12 , 89 75 68 bytes

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

Pruébalo aquí!
Nota: cada vez qque se hace referencia a la salida, no aparece como salida emergente (cualquiera de oOpP) no está disponible o genera una nueva línea pendiente.

Explicación (desactualizado, lo que cambió es que la "H" se imprime usando las letras del alfabeto):

 $             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

Dato curioso: todos los caracteres de los caracteres permitidos están en la página de códigos SOGL: D

Perl 5 , 76 bytes

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

Esto usa una característica que ha quedado en desuso, pero funciona localmente en mi terminal (que es la versión 5.18.2 como se indicó). En versiones anteriores de Perl ?\w?es un sinónimo /\w/que me da acceso a la coincidencia de expresiones regulares y tengo suficientes caracteres para $&(última coincidencia) y $`(texto que precede a la última coincidencia). Necesito estos para poder obtener el O. Genero esto creando una globreferencia ( $_=\*Gque, emitida a un escalar, es algo así comoGLOB(0x7ffb728028d0) ). Una vez que esté dentro $_, ?B?coincidirá con By $`contendrá GLO, entonces puedo comparar con el \w$que se almacenaría Oen$&que se inserta en las cadenas que estoy ejecutando stringwise-AND para crear el resto del texto, el cuerpo de la cadena está en minúsculas usando \L.

Pruébalo en línea! - utiliza /\w/en lugar de ?\w?como la versión de Perl en TIO es demasiado nueva.

Perl 5 , 65 bytes

Esto es un poco más engañoso ya que se basa en el nombre de archivo en TIO (que es .code.tio), por lo que realmente no creo que esto esté compitiendo, ¡pero estuve contento con el resultado!

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

Pruébalo en línea!

Unario , 7 * 10 ¹⁸² bytes

Unario es Brainfuck convertido a binario convertido a unario usando 0como contador. Esencialmente, condensa un programa Brainfuck en un número y la salida es ese número de 0s. Suelen ser programas muy grandes.

No pegaré el programa aquí porque no sé cuánto texto permite SE, pero apuesto a que es menor que esto. En cambio, pegaré el número preciso de ceros en esta respuesta:

708184005756841022918598670049178934705323143517361395031673227349803938380119378597780037353721967636097362645175347036417214959141923667629285233360306016978751166690464736541968556

Como esta es una respuesta bastante barata, garantizada que no será la más corta, y simplemente la copié , estoy haciendo de esto una publicación de wiki.

05AB1E , 137 106 95 bytes

X00X00DXX00DXX00XX0X0X00D0XXXX0X00X00XXX00XXX0XXXXXX00XXXXX0XXXX00D0X000DD00XXJC000gDD0000g***B

Pruébalo en línea!

-31 gracias a @Adnan por señalar que podría usar la base 108.

- ?? Gracias a @Riley por señalar algunas cosas mal.

Versión anterior (método diferente):

05AB1E , 211 186 166 bytes

0g00g000000000gUX000000gXX00000g000g00g000gD0000g0 000g00000gX00000gX00000g0 00000g00000000g0000000g00g00000000gD000000gX0000000g0g00000gUXJX00000000000000000g000g**B

Pruébalo en línea!

¡Jaja! ¡Y AQUÍ PENSÉ QUE ESOLANGS NO DEJÓ OPORTUNIDAD PLAUSIBLE!

Primero obtenemos 255 almacenados en X:

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

Luego, usando el mismo truco de longitud, empujamos: 1296995323340359595058728869715

0g00g000000000g000000g000000000g000000000g00000g000g00g000g000g0000g0 000g00000g000000000g00000g000000000g00000g0 00000g00000000g0000000g00g00000000g00000000g000000g000000000g0000000g0g00000gJ

Donde solo usamos en 0<space>lugar del truco de longitud para los ceros.

Luego, finalmente, empujamos el 255 que almacenamos y convertimos de 255 a base 10 :

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

Todavía jugando golf usando los otros caracteres permitidos, y la duplicación, será un minuto.

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

Pruébalo en línea!

Explicación

Beatnik basa la instrucción ejecutada en función del puntaje de scrabble de la palabra. Aquí hay una explicación abreviada:

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

Pollas de agua (v2.0), 3423 983 923 866 749 716 bytes

Creo que esto se puede jugar un poco, Moorhens no es un lenguaje fácil para trabajar.

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

Explicación

Moorhens es un lenguaje basado en palabras de diccionario. Cada palabra corresponde a una operación basada en su hash. Las cinco operaciones utilizadas aquí son xU, ER, XI, KA, yAA

• xU incrementa los TOS
• ER pone un nuevo cero en la pila.
• XI disminuye los TOS
• KA duplica los TOS
• AA rueda los TOS hacia abajo

Empujamos cada letra con aplicaciones sucesivas de estas operaciones.

Glifo , 480 bytes

AABCABABABBAABABAABCABBAABABABBCABBAABABABABABABABBAABBAABABABABABABABBAABBAAABCABBAABABAABCAABCABBAABABABBCABABABBAABBAABABAABCAABCABBAAABCABBAABABABBAABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABAAABABAABAABBAABCAABABABBAABBAAABCAABCABBAABABABBCABABABBCABABABBAABAAABABAABAABABABBAABABABBAABABABAAABABAABAABBAABABABBAAABCABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABCAABAAABABAABAABBAABABABBCAABCABBAAABCAABCABBAAABCABBAABABABBAABABABBCABABABBAABAAABABABCAABBAAABAABACABBBABCB

Pruébalo en línea!

Headsecks , 78 bytes

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

JavaScript doble, 318 bytes

No estoy seguro de si eso está permitido, no pude hacerlo usando el intérprete de JavaScript una vez. Es similar al uso, eval()pero en su lugar estoy usando el intérprete dos veces: (Pruébelo en la consola para volver a imprimir el resultado)

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

Pruébalo en línea!

Evalúa a:

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

Pruébalo en línea!

Que se evalúa como 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

En realidad, los personajes son un poco irrelevantes. Es solo una cuestión de si cada personaje tiene o no un punto de código par o un punto de código impar. Por lo tanto, hice un esfuerzo para usar todos los caracteres disponibles (excepto los caracteres multibyte) (aunque como era aleatorio, no hice un esfuerzo para garantizarlo).

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

Pruébalo en línea!

Un horrible desastre de código que casi con certeza se puede acortar ... Construye un carácter a la vez.

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

cc , 164 162 bytes

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

Pruébalo en línea!

Es probable que haya un enfoque mejor / más interesante. Intenté usar el truco ASCII + 256 que dctiene, pero que también genera caracteres adicionales (incluso si no se imprimen), y una vez que llegué a 'o', el maravillosamente primo 111, tuve problemas incluso para obtener un valor de 111+ (múltiplo de 256) que se factorizó limpiamente. Así que aquí hay una solución bastante sencilla (aunque golfizada cuando sea posible):

In dc, zes un comando que empuja la profundidad de la pila sobre la pila. Eso significa que podemos usarlo como un incremento. Así es como creo la mayoría de mis valores ASCII para este desafío (impreso con P), con el que empujo a las pilas con nombre Sy vuelvo a la pila principal L.

dcle permite usar los valores hexadecimales AF incluso cuando la raíz de entrada es decimal (predeterminado) Afortunadamente, nuestra primera letra, 72, es un múltiplo de 12, por lo que guardo un byte o dos aquí multiplicando 6 * 12 e imprimiendo inmediatamente ( zzzzzzzC*P). Mi versión de 164 bytes usó la multiplicación desde el principio para obtener 72 ('H'), que era ligeramente inteligente pero un remanente de un intento anterior, y un desperdicio de bytes. Ahora, empiezo incrementando y guardando el espacio, el signo de exclamación y la coma, que están fuera de servicio y, por lo tanto, aún no se pueden imprimir. A continuación, llego a la 'H', que imprimo inmediatamente, antes de llegar a 'W', que debo guardar para más adelante.

Simplemente imprimo cuando presiono la 'e', ​​luego incremento hasta 'l'. Imprimo dos de esos y guardo uno. Cuando llego a 'O', lo primero que pensé que tendría que salvar a uno de los de más adelante, pero todo es tipo de fin en este punto. Imprimo una 'o', recupero mi coma, espacio y 'W' de antes, y ahora vuelvo a 'o'. Imprimo esto e incremento algunos hasta el valor más alto necesario, 'r' (114), que imprimo antes de cargar e imprimir el 'l' que guardé antes.

¡Casi termino! 'd' es el valor ASCII 100, que se crea fácilmente multiplicando 10 * 10 (menos bytes que haberlo almacenado antes y cargarlo ahora). El valor hexadecimal Aes 10, al igual que nuestra raíz de entrada que podemos recuperar con el comando I. Multiplique esos, imprima, y ​​luego cargue e imprima nuestro signo de exclamación de antes. ¡Hola Mundo!