Olá Mundo! com caracteres semi-comuns


28

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 é , então a resposta mais curta em bytes vence.

JSFiddle para verificar se sua resposta é válida


posso imprimir um espaço na próxima linha?
Dzaima 1/08

@dzaima Se você não pode imprimi-lo sem espaço, faça-o. Se livrar-se do espaço só usa mais bytes, livrar-se do espaço
Stephen

Existe um consenso da comunidade (ou isenção / permissão específica aqui) sobre caracteres que não são impressos que chegam à saída (STDOUT)? Não tenho certeza que eu vi ele chegar antes (e seria facilmente esquecido), mas ela muda a minha estratégia dramaticamente aqui ...
brhfl

@brhfl não que eu saiba - a única norma é que novas linhas finais geralmente são permitidas, você pode perguntar no chat
Stephen

Respostas:


6

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


Então ... Você tem um bom emprego estável como desenvolvedor profissional, certo? Porque caramba, essa é uma linguagem legal ... Também bom intérprete de JS, você terminou ontem à noite :)? Você pode começar a postar documentação para alguns idiomas? Ou um bate-papo privado me manda a localização dessa documentação? SOGL mata.
Magic Octopus Urn

@MagicOctopusUrn 1) não, eu tenho 15 anos 2) Eu, pessoalmente, não gosto disso, pois a maneira como ela é feita é a coisa mais corporal que eu já fiz 3) O intérprete JS já está lá há um tempo 4) os últimos documentos sobre Sogl (se você pode chamá-los assim) estão aqui , trough algumas coisas (como a palenChars.txt) são mais atualizado aqui
dzaima

Parabéns por reduzir a contagem de bytes novamente! Sinceramente, acho que não consigo diminuir o meu !!
Dom Hastings

23

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!


Eu não disse nada sobre o conteúdo das bandeiras, então tudo -pbem. Bom trabalho, é isso que eu estava esperando quando eu perguntei isto :)
Stephen

1
como ... o ... o ...
Okx

@StepHen Estou feliz por ter obrigado! Sinceramente, realmente gostei disso. Ainda bem que você não está penalizando a bandeira, atualizarei minha postagem. Obrigado!
Dom Hastings

@ Ok, estou feliz por ter tido esse efeito!
Dom Hastings

Tem certeza de que não precisa adicionar 15 bytes <3?
Magic Octopus Urn

10

Unário , 7 * 10 182 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.


2
"Eu não sei quanto texto o SE permite", pelo menos, não é 7 * 10 is², que é muito maior que 65536.
Erik, o Outgolfer

9

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.


8

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

8

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.


5
'As duas operações' - eu não sou bem versado em esolangs, mas certamente essas são cinco operações?
Boboquack #

@boboquack fixed
Assistente de trigo

1
link para o idioma?
Leaky Nun


5

Glifo , 480 bytes

AABCABABABBAABABAABCABBAABABABBCABBAABABABABABABABBAABBAABABABABABABABBAABBAAABCABBAABABAABCAABCABBAABABABBCABABABBAABBAABABAABCAABCABBAAABCABBAABABABBAABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABAAABABAABAABBAABCAABABABBAABBAAABCAABCABBAABABABBCABABABBCABABABBAABAAABABAABAABABABBAABABABBAABABABAAABABAABAABBAABABABBAAABCABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABCAABAAABABAABAABBAABABABBCAABCABBAAABCAABCABBAAABCABBAABABABBAABABABBCABABABBAABAAABABABCAABBAAABAABACABBBABCB

Experimente online!


4

Headsecks , 78 bytes

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

4

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!


3

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


1
@totallyhuman Você está certo; Eu vou mudar isso. Vou apenas remover os caracteres multibyte. Na verdade, não tem uma página de código; ele só precisa ser armazenado como 1s e 0s (1 para ímpar orde 0 para ainda ord) assim que você poderia dizer que este é 33.25 bytes xD
HyperNeutrino

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

@KSmarts Vou perguntar ao OP sobre isso.
HyperNeutrino 01/08/19

@KSmarts O que isso significa é que, se um idioma tiver uma página de código diferente e, por exemplo, '5'ocupar o ponto de código regular 'A', você não poderá usar '5'.
HyperNeutrino 01/08/19

@KSmarts significa apenas que, se você tiver uma página de código não padrão, esses caracteres se moverão nessa página de código. Você ainda pode usar o ponto de código deles como parte do seu programa.
Stephen

3

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

2

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!

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.