Como alguns de vocês devem saber, para obter um idioma no maravilhoso Try It Online de Dennis ! Olá, mundo! programa é obrigatório. Recentemente, Dennis criou uma maneira de carregar esses programas no site. Aqui está uma pasta JSON dos caracteres usados ​​nesses programas, por frequência, em 27 de julho de 2017.

Alguns desses personagens precisam de um pouco de amor, então seu desafio é produzir Olá, Mundo! (de preferência em um idioma envolvido nesse processo), usando apenas os caracteres especificados abaixo. Esses caracteres são todos os caracteres usados ​​entre 10e 99(inclusive) horas, junto com os dois caracteres mais comuns 0e , porque estou me sentindo bem.

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

Seu uso do personagem deve ser baseado em sua aparência em um programa normal, não em seu valor de ponto de código ou byte.

Você deve usar pelo menos um caractere desse conjunto, para que programas com comprimento 0 sejam inválidos.

Isso é código-golfe , então a resposta mais curta em bytes vence.

JSFiddle para verificar se sua resposta é 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*

Experimente aqui!
Nota: sempre que qou a saída for mencionada aqui, ela não será exibida, pois a saída de popping (qualquer um dos oOpP) não está disponível ou gera uma nova linha precedente.

Explicação (desatualizada, o que mudou é que o "H" é impresso usando as letras do 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

Curiosidade: todos os caracteres dos caracteres permitidos estão na página de códigos SOGLs: D

Perl 5 , 76 bytes

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

Isso usa um recurso que foi descontinuado, mas funciona localmente no meu terminal (que é a versão 5.18.2, conforme observado). Nas versões mais antigas do Perl, ?\w?é um sinônimo /\w/que me dá acesso à correspondência regexp e tenho caracteres suficientes para $&(última correspondência) e $`(texto anterior à última correspondência). Eu preciso deles para conseguir o O. Gero isso criando uma globreferência ( $_=\*Gque, convertida em um escalar, é algo parecidoGLOB(0x7ffb728028d0) ). Quando estiver dentro $_, ?B?corresponderá ao Be $`conterá GLO, eu posso corresponder ao \w$que seria armazenado Oem$&que é inserido nas seqüências de caracteres que estou executando em seqüência de caracteres - AND para criar o restante do texto, o corpo da sequência é minúsculo \L.

Experimente online! - usa /\w/no lugar de ?\w?como a versão do Perl no TIO é muito nova.

Perl 5 , 65 bytes

Isso é um pouco mais barato, pois se baseia no nome do arquivo no TIO (que é .code.tio), então eu realmente não acho que isso esteja competindo, mas fiquei feliz com o resultado!

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

Experimente online!

Unário , 7 * 10 ¹⁸² bytes

Unário é o Brainfuck convertido em binário convertido em unário, usando 0como contador. Essencialmente, ele condensa um programa Brainfuck em um número e a saída é esse número de0 s. Eles geralmente são programas muito grandes.

Não colarei o programa aqui porque não sei quanto texto o SE permite, mas aposto que é menos que isso. Em vez disso, colarei o número exato de zeros nesta resposta:

708184005756841022918598670049178934705323143517361395031673227349803938380119378597780037353721967636097362645175347036417214959141923667629285233360306016978751166690464736541968556

Como esta é uma resposta bastante barata, garantida para não ser a mais curta, e eu simplesmente a copiei , estou fazendo deste um post no wiki.

05AB1E , 137 106 95 bytes

X00X00DXX00DXX00XX0X0X00D0XXXX0X00X00XXX00XXX0XXXXXX00XXXXX0XXXX00D0X000DD00XXJC000gDD0000g***B

Experimente online!

-31 graças a @Adnan por apontar que eu poderia usar a base 108.

- ?? obrigado a @Riley por apontar algumas coisas erradas.

Versão antiga (método diferente):

05AB1E , 211 186 166 bytes

0g00g000000000gUX000000gXX00000g000g00g000gD0000g0 000g00000gX00000gX00000g0 00000g00000000g0000000g00g00000000gD000000gX0000000g0g00000gUXJX00000000000000000g000g**B

Experimente online!

Haha! E AQUI EU PENSEI QUE ESOLANGS NÃO ESTAVA EM CHANCES PLAUSÍVEL!

Primeiro, temos 255 armazenados no X:

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

Então, usando o mesmo truque de comprimento, pressionamos: 1296995323340359595058728869715

0g00g000000000g000000g000000000g000000000g00000g000g00g000g000g0000g0 000g00000g000000000g00000g000000000g00000g0 00000g00000000g0000000g00g00000000g00000000g000000g000000000g0000000g0g00000gJ

Onde apenas usamos 0<space> o truque de comprimento para os zeros.

Finalmente, empurramos os 255 que armazenamos e convertemos de 255 para a base 10 :

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

Ainda jogando golfe usando os outros caracteres permitidos e duplicação, levará um 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

Experimente online!

Explicação

Beatnik baseia a instrução executada com base na pontuação scrabble da palavra. Aqui está uma explicação resumida:

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

Eu acho que isso pode ser um pouco de golfe, Moorhens não é uma linguagem fácil de se trabalhar.

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

Explicação

Moorhens é uma linguagem baseada em palavras do dicionário. Cada palavra corresponde a uma operação baseada em seu hash. As cinco operações usadas aqui são xU, ER, XI, KA, eAA

• xU incrementa os TOS
• ER coloca um novo zero na pilha.
• XI diminui os TOS
• KA duplica os TOS
• AA rola o TOS para o fundo

Pressionamos cada letra com aplicações sucessivas dessas operações.

Glifo , 480 bytes

AABCABABABBAABABAABCABBAABABABBCABBAABABABABABABABBAABBAABABABABABABABBAABBAAABCABBAABABAABCAABCABBAABABABBCABABABBAABBAABABAABCAABCABBAAABCABBAABABABBAABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABAAABABAABAABBAABCAABABABBAABBAAABCAABCABBAABABABBCABABABBCABABABBAABAAABABAABAABABABBAABABABBAABABABAAABABAABAABBAABABABBAAABCABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABCAABAAABABAABAABBAABABABBCAABCABBAAABCAABCABBAAABCABBAABABABBAABABABBCABABABBAABAAABABABCAABBAAABAABACABBBABCB

Experimente online!

Headsecks , 78 bytes

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

JavaScript duplo, 318 bytes

Não tenho certeza se isso é permitido, eu não poderia fazê-lo usando o intérprete JavaScript uma vez. É semelhante ao uso, eval()mas estou usando o intérprete duas vezes: (Experimente no console para obter o resultado impresso novamente)

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

Experimente online!

Avalia para:

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

Experimente online!

O que avalia 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

Na verdade, os personagens são meio irrelevantes. É apenas uma questão de saber se cada caractere tem um ponto de código par ou um ponto de código ímpar. Assim, fiz um esforço para usar todos os caracteres disponíveis (exceto os caracteres multibyte) (embora, como foi randomizado, não fiz um esforço para garantir isso).

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

Experimente online!

Uma bagunça horrível de código que quase certamente pode ser reduzida ... Constrói um caractere de cada 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!"

dc , 164 162 bytes

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

Experimente online!

Provavelmente existe uma abordagem melhor / mais interessante. Eu tentei usar o truque ASCII + 256 quedc possui, mas que também gera caracteres adicionais (mesmo que não sejam impressos), e quando cheguei em 'o', o maravilhosamente primo 111, tive problemas até para obter um valor de 111+ (múltiplo de 256) que foi fatorado de maneira limpa. Então, aqui está uma solução bastante direta (embora possível, sempre que possível):

In dc, zé um comando que empurra a profundidade da pilha para a pilha. Isso significa que podemos usá-lo como um incremento. É assim que eu crio a maioria dos meus valores ASCII para este desafio (impresso com P), com o qual eu empurro para pilhas nomeadas Se coloco de volta na pilha principal L.

dcpermite usar os valores hexadecimais AF, mesmo quando a raiz de entrada é decimal (padrão). Felizmente, nossa primeira carta, 72, é um múltiplo de 12, por isso salvei um byte ou dois aqui multiplicando 6 * 12 e imprimindo imediatamente ( zzzzzzzC*P). Minha versão de 164 bytes utilizou a multiplicação desde o início para obter 72 ('H'), o que era um pouco inteligente, mas um resquício de uma tentativa anterior e um desperdício de bytes. Agora, começo incrementando e economizando espaço, ponto de exclamação e vírgula, que estão com defeito e, portanto, ainda não podem ser impressos. Em seguida, chego ao 'H', que imprimo imediatamente, antes de chegar ao 'W', que devo guardar para mais tarde.

Simplesmente imprimo quando clico no 'e', ​​depois incremento até 'l'. Imprimo dois e guardo um. Quando eu faço-o para 'o', primeiro eu pensei que eu teria que salvar um daqueles para mais tarde, mas tudo é tipo de em ordem neste momento. Imprimo um 'o', recupero minha vírgula, espaço e 'W' mais cedo, e agora estou de volta ao 'o'. Imprimo isso e incremento alguns até o valor mais alto necessário, 'r' (114), que imprimo antes de carregar e imprimir o 'l' que coloquei anteriormente.

Quase pronto! 'd' é o valor ASCII 100, que é facilmente obtido multiplicando 10 x 10 (menos bytes do que armazená-lo anteriormente e carregá-lo agora). Valor hexadecimal Aé 10, como é a nossa raiz de entrada que podemos recuperar com o comando I. Multiplique-os, imprima e carregue e imprima nosso ponto de exclamação anteriormente. Olá Mundo!