Olá Mundo 0.0!


78

Dilbert é incrível
fonte: Dilbert, 8 de setembro de 1992

Espero acrescentar uma nova reviravolta no clássico "Hello World!" programa.

Codifique um programa que saia Hello World!sem:

  • Literais de cadeia / caracteres
  • Números (qualquer base)
  • Funções pré-criadas que retornam "Hello World!"
  • Literais RegEx

Com as exceções de "O" e 0.

† "O" é maiúsculo, "o" não é aceitável.


4
Um de [code-golf] e [code-challenge], por favor, não ambos. O objetivo dessas tags é ajudar as pessoas a encontrar perguntas sobre as regras que desejam usar. Essencialmente, todas as perguntas neste site devem ser um jogo de um tipo ou de outro.
dmckee

4
-1 Já tivemos o Hello World ofuscado , e acho que esse desafio é muito semelhante. Eu teria votado "quase como duplicado", se não fosse um mod.
Chris Jester-Young

2
@zzzzBov: Eu não acho que seja diferente o suficiente para justificar outra pergunta no tema "olá mundo"; um tema diferente teria sido melhor. Mas essa é apenas a minha opinião.
Chris Jester-Young

1
Penso que este é um bom código de golfe - e melhor que o anterior.
MtnViewMark

2
Algumas pessoas parecem assumir que isso "O"*significa que elas podem ter uma string literal com qualquer número de O's, incluindo zero. Eu não acho que essa foi a intenção. Por favor, esclareça.
Timwi

Respostas:


83

Windows PowerShell, demais

Sim, de fato, antigamente, tínhamos que escrever um »Olá, mundo«, usando (quase exclusivamente) zeros ...

&{-join[char[]]($args|% Length)} `
O00000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000

Em uma nota mais grave:

Windows PowerShell, 25

Write-Host Hello World!

Nenhuma string literal. Por Hello World!acaso, o item lá dentro é analisado como uma sequência, pois o PowerShell está no modo de análise de argumentos lá.


2
Como isso é real? O_o
Josh

1
Eu procurei na internet alguns exemplos ou histórico disso. Isto é tão estranho. Você poderia fornecer algum link?
Caleb Jares #

1
"Antigamente". :) Você millennials me rachar-se 👍

Oh. Unário. Entendi.
Matthew Roh

86

C, 327 caracteres

#define O(O)-~O
#define OO(o)O(O(o))
#define Oo(o)OO(OO(o))
#define oO(o)Oo(Oo(o))
#define oo(o)oO(oO(o))
#define O0 putchar
main() {
    O0(OO(oO(!O0(~O(Oo(OO(-O0(~O(Oo(-O0(O(OO(O0(oo(oO(O0(O(oo(oO(OO(Oo(oo(oO(
    O0(oo(oo(!O0(O(OO(O0(O0(O(OO(Oo(O0(O(Oo(oo(oO(O0(oo(oo(oO(oo(oo(0))))))))
    ))))))))))))))))))))))))))))))))))))));
}

Estranhamente, ele não perde sua beleza após o pré-processamento:

main() {
putchar(-~-~-~-~-~-~-~-~-~-~!putchar(~-~-~-~-~-~-~-~-putchar(~-~-~-~-~-~-
putchar(-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~!putchar(-~-~-~putchar(putchar(-~-~-~-~-~-~-~putchar
(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0))))))))))));
}

2
Impressionante. Faltando o!, No entanto.
Mark Reed

1
Isso é arte real!
Askaga

Sinto que o corpo poderia ser reduzido com ainda mais pré-processadores. Não tenho certeza se o código como um todo se beneficiaria.
Zwei

@Zwei, certamente é possível reduzi-lo. Não fiz nenhum esforço para encontrar o conjunto ideal de macros.
Ugoren

Por que você não inclui as parênteses no CLANG #define? economizaria alguns bytes, não? Edit: Nevermind, apenas tentei e agora eu vejo por que isso não vai funcionar ahaha
Albert Renshaw

52

BrainFuck, 102 111 caracteres

++++++++[>++++[>++>+++>+++>+<<<<-]>+>->+>>+[<]<-]>>.>>---.+++++++..+++.>.<<-.>.+++.------.--------.>+.

Atende a todas as regras.

O crédito é para Daniel Cristofani .


1
Não posso decidir se as regras também devem declarar 0 and/or "O" must be used. É um pouco mesquinho para BrainFuck e golfscript, mas eles não têm muita dificuldade com esse desafio.
zzzzBov

34
@zzzzBov: Se eles devem ser usados, o código Brainfuck apenas os incluirá. Porém, eles não afetam o programa.
Joey

38

C, 182 bytes

#define decode(c,o,d,e,g,O,l,f) e##c##d##o
#define HelloWorld decode(a,n,i,m,a,t,e,d)
#define Puzzles(flog) #flog
#define CodeGolf Puzzles(Hello World!)
HelloWorld(){puts(CodeGolf);}

1
+ 1, Lol, você ainda está usando o truque de colar operador! Bom companheiro :-)
Quixotic,

35

Programa C - 45

(traindo)

Lexicamente, isso não usa literais de sequência ou regex. Aproveita o recurso de stringification do pré-processador C. s(x)é uma macro que transforma seu argumento em uma string.

#define s(x)#x
main(){puts(s(Hello World!));}

3
Para uma noção muito conveniente de "lexicamente" :) Mas atrevimento FTW!
JB

24

Haskell - 143 caracteres

o%y=o.o.o$y;o&y=(o%)%y;o!y=o$o$(o%)&y
r=succ;w=pred;a=r%y;e=r$w&l;l=r!'O';o=r e;u=(w&)&a;y=r%l
main=putStrLn[w!o,o,l,l,y,w u,w$r&'O',y,a,l,e,u]

oi, isso foi confuso!

Sem números, sem operações numéricas, variáveis ​​renomeadas para diversão.

Alguma exposição pode ser boa:

  • o%y, o&y, E o!ycada aplica-se a função ode yvárias vezes: 3, 9 e 29 vezes, respectivamente. 29?!?! Sim 29!
  • re wsão os caracteres seguinte e anterior, que quando aplicados usando as funções de ordem superior acima, podem ser criados para obter todos os caracteres necessários 'O'.

A sequência de saltos necessária é:

'O' +29    -> 'l'
'O'  +9 -1 -> 'W'
'l'  -9 +1 -> 'd'
'l'  +3    -> 'o'
'd'  +1    -> 'e'
'o'  +3    -> 'r'
'e' -29    -> 'H'
'r' -81    -> '!'
'!'  -1    -> ' '

  • Edit: (134 -> 144) Esqueceu a saída de um ponto de exclamação, suspiro ....
  • Edit: (144 -> 143) Removido um desnecessário $, renomeado #para !para abraços.

1
oly? oo ....
Joey Adams

Isso não funciona. codepad.org/lyKyj1Ox
nyuszika7h

@ Nyuszika7H Isso ocorre porque esse serviço ativa algumas opções do compilador por padrão. Ele deve compilar com o GHC simples.
FUZxxl

@ Nyuszika7H Funciona muito bem com o GHC. O problema é que esse serviço está usando Hugs a partir de 2006. Parece haver duas coisas com as quais Hugs não consegue lidar: 1) Usando '#' como operador. Mudando para '!' faz funcionar. 2) As definições r=succe os w=predconflitos de como o Hugs implementa a restrição do monomorfismo. Mudar para r x=succ xe w x=pred xfazer funcionar (ao custo de 4 caracteres). Estes parecem ser problemas em abraços.
MtnViewMark

Ainda é válido após a edição @Community?
Hosch250

22

Unários , 10 197 1137672766964589547169964037018563746793726105983919528073581559828 bytes

Estou surpreso que ninguém tenha feito isso ainda ...

É muito longo para postar aqui, mas são 1137672766964589547169964037018563746793726105983919528073581559828 zeros.

Ou, leia mais facilmente: ~ 10 67 zeros.

Obrigado a @dzaima por salvar 10 197 bytes


2
Quando li "Uma vez escrevi um banco de dados inteiro usando apenas zeros", meu primeiro pensamento foi "ele deve ter feito isso em unário". +1 por ser a única resposta para funcionar exatamente como a história em quadrinhos fez #
Cyoce

21

Mathematica 12 caracteres

Apenas símbolos, sem strings.

Hello World!   

O ! é um operador fatorial, mas como os símbolos Olá e Mundo são indefinidos, retorna a entrada inalterada.

Se modificarmos um pouco o programa:

Hello=2;
World=3;
Hello World!  

Em seguida, ele imprime 12(2 * 3!)


16

montagem i386 (Linux, sintaxe gcc), 440 442 435

Hoje é o meu dia de assembléia e depois disso já terei o suficiente por um tempo. Eu me permiti o número 128, veja abaixo o programa para discutir o porquê. Nada de extraordinário: estou apenas codificando "Hello World!" como opcodes de montagem onde isso fazia sentido sem constantes numéricas e preenchia o restante com aritmética.

#define M mov
M $0,%ecx;inc %cx;M %ecx,%ebx;inc %cx;M %ecx,%eax;add %ax,%ax
M %ecx,%edx;shl %cl,%dx;M (e),%ch;add %dl,%ch;dec %ch;M %ch,(l)
M %ch,(j);M %ch,(z);M $0,%ch;shl %cl,%edx;M %dl,(s);inc %dl
M %dl,(b);M (o),%dl;M %dl,(u);add %al,%dl;dec %dl;M %dl,(r)
M $m,%ecx;M $n,%edx;int $c;M %ebx,%eax;M $0,%ebx;int $c
.data
m:dec %eax;e:gs;l:es;j:es;o:outsl (%esi),(%dx)
s:es;push %edi;u:es;r:es;z:es;fs;b:es;n=.-m
t=(n+n)/n;c=t<<(t*t+t)

(monte com gcc -nostartfiles hello.S -o hello, possivelmente -m32dependendo do seu arco)

Por que a tolerância para 128? Eu preciso de syscalls para realmente mostrar qualquer coisa; Os syscalls do Linux estão no INT 80h (128 decimal); o único formato de operando para INT é imediato, portanto, não é possível ter outra coisa senão uma constante (para o código) lá. Eu poderia (depois de ficar sóbrio) tentar expressá-lo como uma função de outras constantes simbólicas no código, provavelmente n , mas isso está ficando muito chato para pouco ganho. Eu li a restrição de números como uma maneira de impedir a codificação ASCII, e definitivamente não é isso que estou fazendo aqui, por isso me sinto inocente o suficiente para enviar isso. (FWIW, eu também tentei o código auto-modificador, mas que foi falhado) Agora também não há 128. O código é puro!

  • Edit1 reformatado para salvar linhas; removeu um numérico 1 (ninguém percebeu ?!)
  • Edit2 compactado movcom macros CPP; eliminou os 128 restantes.

6
É assim que os homens de verdade programam.
Nit

14

Javascript - 305

Um pouco longo, mas eu gosto do método usado.

O=0;O++;O=O.toString();alert([O+0+0+O+0+0+0,0+O+O+0+0+O+0+O,O+O+0+O+O+0+0,O+O+0+O+O+0+0,O+O+0+O+O+O+O,O+0+0+0+0+0,O+0+O+0+O+O+O,O+O+0+O+O+O+O, O+O+O+0+0+O+0,O+O+0+O+O+0+0,O+O+0+0+O+0+0,O+0+0+0+0+O].map(function(e){O=0;O++;O++;return String.fromCharCode(parseInt(e,O))}).reduce(function (a,b){return a+b}))

Eu gosto disso. Seria melhor com parâmetros de função como OO, OOO, mas é claro que tornaria mais tempo.
zzzzBov

Muito legal. O ', new String ()' precisa estar lá no final? Parece funcionar sem ele.
Stephen Perelson

3
Ah, não, não faz. Às vezes eu esqueço o quão fraco é o Javascript.
David4dev 12/03

Você não precisa de 0 bits restantes ('0+'), e o espaço e a exclamação têm dois bits restantes. Redução total de 28 caracteres.
Stephen Perelson 31/03

10

C # (131 caracteres)

141 caracteres 142 caracteres

enum X{Hello,World,A,B=A<<A<<A}class Y{static void Main(){var c=(char)X.B;System.Console.Write(X.Hello.ToString()+c+++X.World+c);}}

Legível:

// Define some constants (B = 32)
enum X { Hello, World, A, B = A << A << A }
class Y
{
    static void Main()
    {
        // Generate the space (character #32)
        var c = (char) X.B;

        // Remember that “!” is character #33
        System.Console.Write(X.Hello.ToString() + c++ + X.World + c);
    }
}

2
isso é torcido e agradável. Eu amo isso.
jcolebrand

+1 de maneira legal de gerar determinados números. Tenho que lembrar disso!
Igby Largeman

Programa LINQPad, 102 caracteres:enum X{Hello,World,A,B=A<<A<<A}void Main(){var c=(char)X.B;(X.Hello.ToString()+c+++X.World+c).Dump();}
Cœur

.ToString()-> +""salva alguns cahrs
Firo 10/07/2014

2
@Firo: ... e quebra as regras. (Sem strings literais permitido.)
Timwi

8

JavaScript, 88

t=!0<<-~-~-~-~!0
r=[]
for(i in{Hello:"O",World:0})r+=i+String.fromCharCode(t++)
alert(r)

99

Muito obrigado a @Timwi pelas sugestões

operador ternário removido:

o={Hello:"O",World:0}
t=!0<<-~-~-~-~!0
c=String.fromCharCode
r=c(0)
for(i in o)r+=i+c(t++)
alert(r)

103
aliasString.fromCharCode

o={Hello:"O",World:0}
t=!0<<-~-~-~-~!0
c=String.fromCharCode
for(i in o)o[i]?r=i+c(t):alert(r+i+c(++t))

117
Comutador if-else para operador ternário

o={Hello:"O",World:0},t=!0<<-~-~-~-~!0
for(i in o)o[i]?r=i+String.fromCharCode(t):alert(r+i+String.fromCharCode(++t))

125
Estou mantendo o "O"justo para ter um "O" no programa.

o={Hello:"O",World:0},t=!0<<-~-~-~-~!0
for(i in o)if(o[i])r=i+String.fromCharCode(t)
else alert(r+i+String.fromCharCode(++t))

133

o={Hello:"O",World:0},t=!0<<(!0+!0<<!0)+!0
for(i in o)if(o[i])r=i+String.fromCharCode(t)
else r+=i+String.fromCharCode(t+!0)
alert(r)

@ Joey, esse é basicamente o ponto.
zzzzBov

@ Joey, li na meta do codegolf que é preciso evitar responder sua própria pergunta por algum tempo para incentivar outras pessoas a tentar várias abordagens diferentes. Meu plano era descomentá-lo em um dia ou dois.
zzzzBov

@ Joey, não estava trabalhando na minha própria máquina na época, e eu não estava com vontade de me enviar a resposta por e-mail quando eu poderia apenas postá-la em um comentário.
zzzzBov

@ Joey: "Existem apenas cinco desses" está errado. Qualquer pessoa pode sugerir uma edição. Basta clicar em "editar" entre "link" e "flag" e você poderá ver o código.
John

@zzz: "esse é basicamente o ponto" Qualquer um ainda pode vê-lo. Qualquer pessoa pode sugerir uma edição clicando em "editar" entre "link" e "sinalizador", que exibirá a caixa de diálogo de edição, revelando seu código.
John John

7

GolfScript, 63 caracteres

[0))):O.)?O.*-.O.?+)).O.*+((..O+.O(.O+?.O-O*@.O+O.+$.O.*-).O/]+

Ainda não existe uma entrada no GolfScript?

Este usa um único literal numérico 0e uma variável chamada O(que é usada para armazenar o número 3). Tudo o resto é aritmético e manipulação de pilha. A cadeia Hello World!é criada a partir de seus códigos ASCII, caractere por caractere.

Veja como funciona:

[             # insert start-of-array marker
  0))):O      # increment 0 thrice to get 3, and save it in the variable O
  .)?O.*-     # calculate 3^(3+1) - 3*3 = 81 - 9 = 72 = "H" 
  .O.?+))     # calculate 72 + 3^3 + 1 + 1 = 72 + 27 + 2 = 101 = "e"
  .O.*+((     # calculate 101 + 3*3 - 1 - 1 = 101 + 9 - 2 = 108 = "l"
  .           # ...and duplicate it for another "l"
  .O+         # calculate 108 + 3 = 111 = "o"
  .           # ...and duplicate it for later use
  O(.O+?      # calculate (3-1)^(3-1+3) = 2^5 = 32 = " "
  .O-O*       # calculate (32 - 3) * 3 = 29 * 3 = 87 = "W"
  @           # pull the second 111 = "o" to the top of the stack
  .O+         # calculate 111 + 3 = 114 = "r"
  O.+$        # copy the (3+3 = 6)th last element on the stack, 108 = "l", to top
  .O.*-)      # calculate 108 - (3*3) + 1 = 108 - 9 + 1 = 100 = "d"
  .O/         # calculate int(100 / 3) = 33 = "!"
]             # collect everything after the [ into an array
+             # stringify the array by appending it to the input string

7

Brainfuck, 111 bytes

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++
.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.
------.--------.>+.>.

Algoritmo explicado

Increment cell 0 to 10 (it will be loop counter)
Repeat 10 times ; will stop at cell 0
  Increment cell 1 to 7
  Increment cell 2 to 10
  Increment cell 3 to 3
  Increment cell 4 to 1
Increment cell 1 by 2 and output it ; Thus, output ASCII 72 'H'
etc. for all symbols in 'Hello World!'

Versão mais longa sem loop, 389 bytes:

+++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.+++++++++++++++++
++++++++++++.+++++++..+++.-------------------
---------------------------------------------
---------------.+++++++++++++++++++++++++++++
++++++++++++++++++++++++++.++++++++++++++++++
++++++.+++.------.--------.------------------
---------------------------------------------
----.-----------------------.

Este é um quebra-cabeça de código-golfe, o objetivo é tornar o programa o mais curto possível. Parte disso envolve a publicação do comprimento do seu código.
zzzzBov

5

Lua 144 97 86 caracteres

Uma abordagem diferente, baseada no fato de que as chaves da tabela também são cadeias de caracteres e no fato de que #Hello == #World == 32 == string.byte '\ n'

e=#"O"t=e+e for k,v in pairs{Hello=0,World=e}do T=t^#k io.write(k,string.char(T+v))end

Solução de 145 caracteres

  • sem strings, exceto "O" ou 0
  • sem Regexes
  • sem funções pré-construídas

Fiz codificação delta dos bytes, então alguns números primos etc etc :)

Versão Golfed:

e=#"O"d=e+e t=d+e v=d+t z=v+t T=t^d*d^t n=0 for l,m in pairs{T,T/t-z,z,0,d,-T-z,z*z+t*d,T/d,d,-d*t,-t^d,-T+v}do n=n+m io.write(string.char(n))end

Comentado:

-- without numbers, strings, regex
-- except "O" and 0
e=#"0"
t=e+e --2
d=t+e -- 3
v=d+t -- 5
z=v+t -- 7
n=0
T=t^d*d^t -- 72 = 2^3+3^2
for l,m in pairs{T, --72
T/t-z, -- 29 = 72/2-7
z, --7
0, -- 0
d, -- 3
-T-z, -- -79 = -72 - 7
z*z+t*d, -- 55 = 7*7 + 2*3
T/d, -- 24 = 72/3
d, -- 3
-d*t, -- -6
-t^d, -- -8
-T+v -- -67 = -72+5
} do
    n=n+q[k]
    io.write(string.char(n))
end

Edit: Alterou várias strings O e encontrou mais otimizações.


"O" * - acho que o * era para a nota de rodapé, não "qualquer número de O's"
romanst 12/03/11

Bem, regexar é o que eu naturalmente faço: p. Poderia substituí-lo à custa de 5 ou 3 caracteres adicionais para, respectivamente, a primeira e segunda solução
jpjacobs

Mas de qualquer maneira, eu vou editá-los para fora, graças a cabeça para cima
jpjacobs

Hello e World no construtor de tabelas ainda são literais de string - isso é apenas um açúcar sintático.
Oleg V. Volkov

5

Python ( 126 130)

O=ord("O")
N=O/O
T=N+N
R=N+T
E=T**R
E<<T
print'O'[0].join(chr(c+O)for c in[N-E,E*R-T,_-R,_-R,_,N-_-E-E,E,_,_+R,_-R,E*R-R,T-_-E-E])

O literal ''não é permitido.
RomanSt

1
@romkyns: muito verdadeiro, fixo.
Hoa Long Tam

5
Não fixo (saída incorreta). Você provavelmente está pensando [:0].
WolframH

5

J, 250

oo=:#a.
o0=:<.o.^0
o0o=:%:%:%:oo
ooo=:p:^:(-*oo)
o=:<.(^^^0)*(^^0)*(^^0)
o00=:o,~(,[)o0(**(**[))o0o
oo0=:*/p:(!0),>:p:!0
echo u:(o0(**(**]))o0o),(ooo ooo ooo(o.o.^^^0)*oo),o00,(+:%:oo),(oo0-~!p:>:>:0),o,(<.-:o.o.^o.^0),(>:p:(]^])#o00),(*:#0,#:oo),oo0

Eu me diverti muito com esse e aprendi um pouco mais de J para inicializar. Além disso, ooo ooo ooopode ser o código mais estúpido que eu já escrevi.


5

QR with halfblocks (169) 121 caracteres

Com o QR-Code usando caracteres UTF-8 de meio bloco:

▗▄▄▄▗▄▖▗▄▄▄  
▐▗▄▐▝█▙▐▗▄▐  
▐▐█▐▝▄ ▐▐█▐  
▐▄▄▟▗▗▗▐▄▄▟  
▗▗▖▄▞▝ ▗ ▖▄  
 ▟▜ Code ▀▟  
 ▙▀ Golf ▘▚  
▗▄▄▄▐▗▘▟▙▝▝  
▐▗▄▐▝▀▛▘▘█▖  
▐▐█▐▐▖▐▝▖▜▘  
▐▄▄▟▗ ▌█▛▗▝  3

Infelizmente, isso não vai render muito bem lá. Há um pequeno trecho com a folha de estilos apropriada, mas .. Não! A linguagem apresentada aqui não é HTML! O idioma apresentado aqui é o QR Code ! (HTML e CSS são usados ​​aqui apenas para solucionar problemas de apresentação!)

QR com halfblocks (169)

  ▛▀▀▌▚▝▐▀▌▛▀▀▌
  ▌█▌▌▖▞▚▚▘▌█▌▌
  ▌▀▘▌ ▚▛▞ ▌▀▘▌
  ▀▀▀▘▚▌▙▘▌▀▀▀▘
  ▄▙▛▚▜▀▄▀█▖▝▄▌
  ▖▄▄▘▖▄▄▄▟▗ ▀▘
  ▜Code  golf!▌
  ▚▟▘▘▝▙▛▚▐▀▖▜▘
  ▘▘ ▀▛▗▚▗▛▀▌▄ 
  ▛▀▀▌▟▌▜▖▌▘█▐▘
  ▌█▌▌▘█▌▟█▜▙▐ 
  ▌▀▘▌▚▌▌█▗▝▌▚▘
  ▀▀▀▘ ▝▘▘▀▀▀▀▘

Idealmente, isso pode se parecer com:

QR: Olá Mundo!


Use seu telefone inteligente para ver isso ou zbarno Linux. (exemplo: xwd | xwdtopnm | zbarimg /dev/stdin)
F. Hauri

Code golf!Um personagem não é literal?
Ugoren

2
Na verdade, acho que essa resposta, embora criativa, não se qualifica porque não é um programa. O QR é uma maneira de codificar dados, não uma linguagem de programação.
Ugoren

1
Também o que acontece com línguas como postscript, svgou outras linguagens de apresentação já utilizado lá !? Uma maneira de codificar é uma linguagem de qualquer maneira ... eu acho!
F. Hauri 05/02

1
Eu usei HTML (menos JS) como um exemplo para o que não é uma linguagem. O mesmo vale para o QR. Veja estes critérios .
ugoren

4

Scala ( 357 423 361 caracteres)

Infelizmente, não é a resposta mais curta, mas esperamos obter bônus para o melhor uso 'O'e'0'

def h(){type t=scala.Char;def OO(c:t)={(c-('O'/'O')).toChar};def O(c:t)={OO(OO(OO(c)))};def O00(c:t)={(c+('O'/'O')).toChar};def O0(c:t)={O00(O00(O00(c)))};val l=O('O');val z=O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0)))))))))));print(OO(O(O('O'))).toString+(OO(O(O(O('O')))).toString+l+l+'O'+OO(z)+O0(O0(O0(OO('O'))))+'O'+O0('O')+l+OO(OO(O(O(O('O')))))+z).toLowerCase)}

Anteriormente:

def h(){type t=scala.Char;print(OO(O(O('O'))).toString+(OO(O(O(O('O')))).toString+O('O')+O('O')+'O'+OO(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0))))))))))))+O0(O0(O0(OO('O'))))+'O'+O0('O')+O('O')+OO(OO(O(O(O('O')))))+O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0)))))))))))).toLowerCase);def OO[Char](c:t)={(c-('O'/'O')).toChar};def O[Char](c:t)={OO(OO(OO(c)))};def O00[Char](c:t)={(c+('O'/'O')).toChar};def O0[Char](c:t)={O00(O00(O00(c)))}}

Versão antiga (ilegal):

def h(){type t=scala.Char;print(""+OO(O(O('O')))+(""+OO(O(O(O('O'))))+O('O')+O('O')+'O'+OO(O(O(O(O(O('0'))))))+O0(O0(O0(OO('O'))))+'O'+O0('O')+O('O')+OO(OO(O(O(O('O')))))+O(O(O(O(O('0')))))).toLowerCase);def O0[Char](c:t)={O00(O00(O00(c)))};def O[Char](c:t)={OO(OO(OO(c)))};def OO[Char](c:t)={(c-('O'/'O')).toChar};def O00[Char](c:t)={(c+('O'/'O')).toChar}}

Eu acredito que a string vazia ( "") e literais de caracteres / caracteres que contêm o caractere zero ( '0') não são permitidos. Somente a sequência "O"(maiúscula O) e o número 0são.
Timwi

Bugger. Alguns edição necessária, então ...
Gareth

4

C (ou C ++) (segmento do corpo: 49) (trapaça)

Ao compilar, compilar com um binário chamado Hello\ World\!, o código é:

#include <stdio.h>
#include <string.h>
int main(int i,char**a)
{
  int j=i+i,k=j<<j;puts(strrchr(*a,'O'-(k<<j))+i);
}

O strrchrsegmento é necessário para remover o caminho completo, caso o nome do programa passado contenha o caminho completo, também nenhum argumento deve ser passado .

A linha de compilação típica pode ser: gcc -o Hello\ World\! foo.c


3

C ++, 141, 146

A primeira vez que experimentamos um desses, provavelmente ainda pode ser melhorada um pouco:

char o='O'/'O',T=o+o,X=T+o,f=T+X,t=f+f,F=t*f,h=F+F,l=h+t-T,O=l+X;
char c[]={F+t+t+T,h+o,l,l,O,o<<f,h-t-X,O,l+f+o,l,h,0};
cout<<c;

EDITAR:

Roubei o truque de dividir de outro post, não acredito que não pensei nisso :(


1
Tecnicamente, você deve incluir todo o programa de trabalho na contagem de caracteres, incluindo coisas como main, quaisquer bibliotecas incluídas std::, etc. etc #
Wug

3

Haskell - 146

a:b:c:f:g:s:j:z=iterate(\x->x+x)$succ 0
y=[f+j,d+a,c+s+h,l,a+b+l,s,f-s+o,o,a+b+o,l,l-f,a+s]
[h,e,l,_,o,_,w,_,r,_,d,x]=y
main=putStrLn$map toEnum y

Imaginei que a correspondência de padrões daria a Haskell uma grande vantagem, em particular porque você pode inicializar poderes de dois assim:

one:two:four:eight:sixteen:thirty_two:sixty_four:the_rest = iterate (*2) 1

No entanto, como visto na resposta Haskell do MtnViewMark (que merece muitos upvotes, a propósito) e outras respostas, uma melhor compactação pode ser alcançada usando mais do que apenas +e -.


3

Clojure - 46 caracteres

(map print(butlast(rest(str'(Hello World!)))))

Observe que Helloe World!são símbolos, não literais de qualquer tipo.


3

C ++

/*
Hello World!
*/
#define CodeGolf(r) #r
#include<iostream>
using namespace std;
int main()
{
    char str[*"O"];
    freopen(__FILE__,CodeGolf(r),stdin);
    gets(str);gets(str);puts(str);
}

1
O 100viola a regra sobre números. Substitua-o por algo mais divertido.
Joey Adams

@ joey-adams Obrigado por apontar. Mudou isso.
FR0DDY 13/03/11

Line 7: error: ISO C++ forbids declaration of 'main' with no type
Nathan Osman

@ george-edison Corrigido. Embora funcionou sem intno g ++ #
fR0DDY

3

PHP - 49 caracteres

<?=Hello.chr(($a=-~-~-~0).~-$a).World.chr($a.$a);

Changelog :

  • (73 -> 86) Esqueci de emitir um ponto de exclamação ... suspiro
  • (86 -> 57) Usa uma única variável com incrementos
  • (57 -> 51) Alterado para usar operadores bit a bit em 0
  • (51 -> 49) Mais operadores bit a bit

1
Certeza de que as constantes contariam como literais de sequência por causa das conversões.
22711 Kevin Kevin Brown

@ Bass5098 Obrigado pela sua edição! Eu aprovei.
nyuszika7h

@ Bass5098 que não funciona, você precisa ter os caracteres 32 e 33, não 21 e 22. <?$a=-~-~-~0;echo Hello.chr($a.$a-1).World.chr($a.$a);funciona, mas são 54 caracteres.
ZzzzBov

@zzzzBov Não consegui descobrir como limpar a edição inicialmente e esqueci de revertê-la depois de aprovada.
Kevin Brown

gritos, eu deixei o 1lá dentro. Lá vou eu quebrando minhas próprias regras ... <?$a=-~-~-~0;echo Hello,chr($a.~-$a),World,chr($a.$a);é o que eu deveria ter usado, ainda 54 caracteres.
zzzzBov

3

Python, 106

o=-~-~-~0
L=o+o
d,W=-~L,o**o
_=o*W
print str().join(chr(L+W+_-i)for i in[d*L,L+d,L,L,o,-~_,W,o,0,L,d+d,_])

Use '' (sem espaço anterior) em vez de str ()
aditsu 19/03/2013

2
Além disso, muito bom! :) Aliás, a atribuição múltipla não está salvando nenhum caractere
aditsu 19/03/2013

@aditsu: Eu não posso, isso seria uma string literal. Obrigado por seus comentários. :)
flornquake

Oh oops, de alguma forma, a cadeia vazia não se registrar como um literal em minha mente
aditsu

3

Perl, 186 bytes

@A=(0,0,0,0);@B=(@A,@A);@C=(@B,@B);@D=(@C,@C);@E=(@D,@D);@d=(@E,@D,@A);$l=[@d,@B];$o=[@$l,0,0,0];print(chr@$_)for[@E,@B],[@d,0],$l,$l,$o,\@D,[@E,@C,@A,0,0,0],$o,[@$o,0,0,0],$l,\@d,[@D,0]

Cada caractere é impresso através do seu número ordinal, que é o comprimento de uma matriz. A construção das matrizes é otimizada através da representação binária dos números de caracteres.

Ungolfed:

@A = (0, 0, 0, 0);          # A = 2^2
@B = (@A, @A);              # B = 2^3
@C = (@B, @B);              # C = 2^4
@D = (@C, @C);              # D = 2^5
@E = (@D, @D);              # E = 2^6

# d = 100 = 0x64 = 1100100b
@d = (@E, @D, @A);          # d = 2^6 + 2^5 + 2^2 

# l = 108 = 0x6C = 1101100b
$l = [@d, @B];              # l = d + 2^3

# o = 111 = 0x6F = 1101111b
$o = [@$l, 0, 0, 0];        # o = l + 3

print (chr @$_) for
    [@E, @B],              # "H"    H  =  72 = 0x48 = 1001000b = 2^6 + 2^3
    [@d, 0],               # "e"    e  = 101 = 0x65 = 1100101b = d + 1  
    $l, $l, $o,            # "llo"
    \@D,                   # " "   ' ' =  32 = 0x20 = 0100000b = 2^5
    [@E, @C, @A, 0, 0, 0], # "W"    W  =  87 = 0x57 = 1010111b = 2^6 + 2^4 + 2^2 + 3
    $o,                    # "o"
    [@$o, 0, 0, 0],        # "r"    r  = 114 = 0x72 = 1110010b = o + 3
    $l, \@d,               # "ld"
    [@D,0]                 # "!"    !  =  33 = 0x21 = 0100001b = 2^5 + 1

Parece que o meu vodoo binário inspirou :) +1
masterX244

3

Java 389 caracteres

viu uma declaração desnecessária

class A{static int a=0,b=a++,f=a,e=a++;static char p(String s){return(char)Byte.parseByte(s,a);}public static void main(String[]z){long x=e,y=b;String c=((Long)x).toString(),d=((Long)y).toString();char l=p(c+c+d+c+c+d+d),m=p(c+c+d+d+c+d+c),o=(char)(l+a+f),_=p(c+d+d+d+d+d),$=_++;System.out.print(new char[]{p(c+d+d+c+d+d+d),m,l,l,o,$,p(c+d+c+d+c+c+c),o,(char)(o+a+f),l,(char)(m-f),_});}}

O histórico está no histórico de edições agora com a versão original não-legível:

// H  e  l    l   o      W  o  r   l    d  !
//72,101,108,108,111,32,87,111,114,108,100 33
import static java.lang.Integer.*;
class A
{


    public static void main(String[] args)
    {
        Integer a=0,b=a++,e=a++;  // making a 0 a 1 and a 2 which is required later;
        String c=e.toString(),d=b.toString(),z=c.substring(0,0);  //

        String H = ((char)parseInt(d+c+d+d+c+d+d+d,a))+z+  // make binary values and then to char
                (char)parseInt(d+c+c+d+d+c+d+c,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+c+c+c+c,a)+
                (char)parseInt(d+d+c+d+d+d+d+d,a)+
                (char)parseInt(d+c+d+c+d+c+c+c,a)+
                (char)parseInt(d+c+c+d+c+c+c+c,a)+
                (char)parseInt(d+c+c+c+d+d+c+d,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+d+c+d+d,a)+
                (char)parseInt(d+d+c+d+d+d+d+c,a)
                ;
        System.out.println(H);  //obvious
    }

3

Perl 6 , 199 bytes

my \O=+[0];my \t=O+O;my \T=t+O;my \f=(t+t,O);my \F=t+T;my \S=T+T;my \L=(S,F);
say [~] ((S,T),(|L,t,0),(my \l=(|L,T,t)),l,(my \o=(|l,O,0)),F,(S,|f,t,0),o,(|L,|f),l,(|L,t),(F,0),)
.map({chr [+] t X**@_})

(novas linhas são adicionadas para reduzir a largura, mas são desnecessárias, portanto não são contadas)


Hello World! é codificado como uma lista de listas dos poderes de 2 de cada letra.

Há exatamente um lugar onde eu tenho um literal 0que é usado para qualquer coisa que não seja a 0. É usado para criar uma lista de um elemento, que é imediatamente transformada no número 1com o operador de prefixo numérico ( +[0]).

my \O=+[0];    # one          # (List.elems)
my \t=O+O;     # two
my \T=t+O;     # Three
my \f=(t+t,O); # (four, one)  # <W r>
my \F=t+T;     # five
my \S=T+T;     # six

my \L=(S,F);   # lowercase letter  # (6,5)

say [~] (
  (S,T),            # H
  (|L,t,0),         # e
  (my \l=(|L,T,t)), # l
  l,                # l  reuse <l>
  (my \o=(|l,O,0)), # o  reuse <l>, add 0,1
  F,                # ␠
  (S,|f,t,0),       # W
  o,                # o  reuse <o>
  (|L,|f),          # r
  l,                # l  reuse <l>
  (|L,t),           # d
  (F,0),            # !
).map({chr [+] t X**@_})

3

Caracteres JavaScript 662

O=[[,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[],[,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]];for(O_O=[].length;O.length>O_O;O_O++)document.write(String.fromCharCode((O[O_O].length||-Math.pow([,,].length,[,,,,,].length)-[,,,,,,,].length)+Math.pow([,,].length,[,,,,,,].length)+Math.pow(++[,].length,[,,,].length)-[,].length));document.write(String.fromCharCode(Math.pow([,,].length,[,,,,,].length)+[,].length))

Que tal abusar de literais de matriz apenas para ter uma base unária. Este programa tem vantagem de não usar 0.


Embora isso possa ser válido, esse quebra-cabeça em particular é um código de golfe, o que significa que você deve procurar o código mais curto possível. Com mais de 600 caracteres, você não está nem perto dos <100 caracteres que as soluções JS existentes já possuem.
zzzzBov

1
@zzzzBov: Na verdade, não estou tentando vencer.
precisa

1
Este programa tem vantagem de não usar 0. Que tal O_O=0;?
Erik the Outgolfer

@EriktheGolfer: Corrigido, obrigado. Eu não percebi isso.
Konrad Borowski

O_O=[].lengthpode ser escrito como o O_O=falsediminui em 4
Atmocreations 26/10/16
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.