Hola mundo 0.0!

78

Dilbert es asombroso
fuente: Dilbert, 8 de septiembre de 1992

Espero agregar un nuevo giro al clásico "¡Hola Mundo!" programa.

Codifique un programa que salga Hello World!sin:

  • Cadena / literales de caracteres
  • Números (cualquier base)
  • Funciones preconstruidas que devuelven "Hello World!"
  • RegEx literales

Con las excepciones de "O" y 0.

† "O" está en mayúscula, "o" no es aceptable.

zzzzBov
fuente
44
Uno de [code-golf] y [code-challenge], por favor, no ambos. El objetivo de estas etiquetas es ayudar a las personas a encontrar preguntas con las reglas que desean usar. Esencialmente, cada pregunta en este sitio debe ser un juego de algún tipo u otro.
dmckee
44
-1 Ya hemos tenido Ofuscado Hello World , y creo que este desafío es demasiado similar. Hubiera emitido un voto de "cerrar como duplicado", si no fuera un mod.
Chris Jester-Young
2
@zzzzBov: No creo que sea lo suficientemente diferente como para justificar otra pregunta en el tema "hola mundo"; un tema diferente hubiera sido mejor. Pero esa es solo mi opinión.
Chris Jester-Young
1
Creo que este es un buen código de golf, y mejor que el anterior.
MtnViewMark
2
Algunas personas parecen suponer que eso "O"*significa que pueden tener un literal de cadena con cualquier número de O, incluido cero. No creo que esa fuera la intención. Por favor aclarar
Timwi

Respuestas:

83

Windows PowerShell, demasiado

Sí, de hecho, antes teníamos que escribir un »Hola mundo« usando ceros (casi exclusivamente) ...

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

En una nota más seria:

Windows PowerShell, 25

Write-Host Hello World!

Sin cadena literal. El Hello World!allí sólo pasa a ser analizada como una cadena desde PowerShell está en el modo de análisis argumento allí.

Joey
fuente
2
¿Cómo es eso real? O_o
Josh
1
Busqué en Internet algunos ejemplos o antecedentes de esto. Esto es tan extraño. ¿Podría proporcionar algún enlace?
Caleb Jares
1
"En mis tiempos". :) Ustedes millennials me hacen
Oh. Unario Lo entiendo.
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))))))))
    ))))))))))))))))))))))))))))))))))))));
}

Curiosamente, no pierde su belleza después del preprocesamiento:

main() {
putchar(-~-~-~-~-~-~-~-~-~-~!putchar(~-~-~-~-~-~-~-~-putchar(~-~-~-~-~-~-
putchar(-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~!putchar(-~-~-~putchar(putchar(-~-~-~-~-~-~-~putchar
(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0))))))))))));
}
Ugoren
fuente
2
Increíble. Sin embargo, falta el!
Mark Reed
1
¡Esto es arte real!
Askaga
Siento que el cuerpo podría acortarse con aún más preprocesadores. Sin embargo, no estoy seguro de si el código en su conjunto se beneficiaría.
Zwei
@Zwei, ciertamente es posible acortarlo. No hice ningún esfuerzo por encontrar el conjunto óptimo de macros.
ugoren
¿Por qué no incluye a los padres en CLANG #define? ahorraría unos pocos bytes, ¿no? Editar: no importa, solo lo intenté y ahora veo por qué eso no funcionará jajaja
Albert Renshaw
52

BrainFuck, 102 111 caracteres

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

Cumple con todas las reglas.

El crédito va para Daniel Cristofani .

Kevin Brown
fuente
1
No puedo decidir si las reglas también deberían indicar 0 and/or "O" must be used. Es un poco malo para BrainFuck y golfscript, pero no tienen exactamente dificultades con este desafío.
zzzzBov
34
@zzzzBov: Si deben usarse, entonces el código Brainfuck solo los incluirá. Sin embargo, no afectan el programa en absoluto.
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);}
fR0DDY
fuente
1
+ 1, Lol, ¡sigues usando el truco del operador de pegar fichas! Buen compañero :-)
Quixotic
35

Programa C - 45

(engañando)

Léxicamente, esto no usa ningún literal de cadena o literal de expresiones regulares. Aprovecha la función de stringificación del preprocesador C. s(x)es una macro que convierte su argumento en una cadena.

#define s(x)#x
main(){puts(s(Hello World!));}
Joey Adams
fuente
3
Para una noción muy conveniente de "léxico" :) Pero descarado 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]

oy, eso fue lanudo!

Sin números, sin operaciones numéricas, variables renombradas para diversión.

Alguna exposición puede ser buena:

  • o%y,, o&yy o!ycada uno aplica la función oa ymúltiples veces: 3, 9 y 29 veces respectivamente. 29?!?! Si, 29!
  • ry wson los caracteres siguientes y anteriores, que cuando se aplican utilizando las funciones de orden superior anteriores se pueden hacer para obtener todos los caracteres necesarios 'O'.

La secuencia de saltos necesarios es:

'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    -> ' '

  • Editar: (134 -> 144) Olvidé mostrar un signo de exclamación, suspiro ...
  • Editar: (144 -> 143) ha eliminado un innecesario $, rebautizado #a !para los abrazos.
MtnViewMark
fuente
1
o rly? oo ....
Joey Adams
No funciona codepad.org/lyKyj1Ox
nyuszika7h
@ Nyuszika7H Esto se debe a que este servicio activa algunas opciones del compilador de forma predeterminada. Debe compilarse con GHC simple.
FUZxxl
@ Nyuszika7H Funciona bien con GHC. El problema es que ese servicio usa Hugs desde 2006. Parece que hay dos cosas con las que Hugs no puede lidiar: 1) Usar '#' como operador. Cambiando a '!' lo hace funcionar 2) Las definiciones de r=succy en w=predconflicto con la forma en que Hugs implementa la restricción de monomorfismo. Cambia r x=succ xy w x=pred xhace que funcione (a costa de 4 caracteres). Estos parecen ser problemas en los abrazos.
MtnViewMark
¿Sigue siendo válido después de la edición @Community?
Hosch250
22

Unario , 10 197 1137672766964589547169964037018563746793726105983919528073581559828 bytes

Me sorprende que nadie haya hecho esto todavía ...

Es demasiado largo para publicar aquí, pero son 1137672766964589547169964037018563746793726105983919528073581559828 ceros.

O, lea más fácilmente: ~ 10 67 ceros.

Gracias a @dzaima por guardar 10 197 bytes

Decaimiento Beta
fuente
2
Cuando leí "Una vez escribí una base de datos completa usando solo ceros", mi primer pensamiento fue "debe haberlo hecho en unario". +1 por ser la única respuesta para trabajar exactamente como lo hizo el cómic
Cyoce
21

Mathematica 12 caracteres

Solo símbolos, sin cadenas.

Hello World!   

Los ! es un operador factorial, pero como los símbolos Hello y World no están definidos, devuelve la entrada sin cambios.

Si modificamos un poco el programa:

Hello=2;
World=3;
Hello World!  

Luego imprime 12(2 * 3!)

Dr. belisario
fuente
16

Ensamblado i386 (Linux, sintaxis gcc), 440 442 435

Hoy es mi día de asamblea, y después de eso tendré suficiente por un tiempo. Me permití el número 128, ver el programa a continuación para discutir por qué. Nada extraordinario: solo estoy codificando "¡Hola Mundo!" como códigos de operación de ensamblaje donde eso tenía sentido sin constantes numéricas, y completaba el resto con 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)

(ensamblar gcc -nostartfiles hello.S -o hello, posiblemente -m32según su arco)

¿Por qué la tolerancia para 128? Necesito syscalls para mostrar realmente cualquier cosa; Las llamadas del sistema Linux están en INT 80h (128 decimales); El único formato de operando para INT es inmediato, por lo que no es posible tener nada más que una constante (para el código) allí. Yo pude (después de obtener sobrio) intentar expresarlo en función de otras constantes simbólicas en el código, probablemente n , sino que está poniendo muy aburrido para no mucha ganancia. Leí la restricción sobre los números como una forma de evitar la codificación ASCII, y eso definitivamente no es lo que estoy haciendo aquí, así que me siento lo suficientemente inocente como para enviar esto. (FWIW, también probé el código de auto modificación, pero eso falló) Ahora tampoco quedan 128. ¡El código es puro!

  • Edit1 reformateado para guardar líneas; eliminó un número 1 (¿nadie se dio cuenta?)
  • Edit2 comprimido movcon macros CPP; eliminó los 128 restantes.
JB
fuente
66
Así es como los hombres de verdad programan.
Nit
14

Javascript - 305

Un poco largo pero me gusta el método utilizado.

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}))
david4dev
fuente
Me gusta. Sería mejor con los parámetros de función como OO, OOOpero por supuesto que lo harían más tiempo.
zzzzBov
Muy agradable. ¿Es necesario que ', new String ()' esté allí al final? Parece funcionar sin él.
Stephen Perelson
3
Ah, no, no lo hace. A veces olvido cuán débilmente está escrito Javascript.
david4dev
Tampoco necesita 0 bits a la izquierda ('0+'), y el espacio y la exclamación tienen dos bits a la izquierda. Reducción total de 28 caracteres.
Stephen Perelson
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);}}

Legible:

// 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);
    }
}
Timwi
fuente
2
Esto es retorcido y agradable. Me encanta.
jcolebrand
+1 buena manera de generar ciertos números. Tengo que recordar eso!
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()-> +""ahorra algunos cahrs
Firo
2
@Firo: ... y rompe las reglas. (No se permiten literales de cadena.)
Timwi
8

JavaScript, 88

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

99

Muchas gracias a @Timwi por las sugerencias.

operador ternario eliminado:

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
Conmutado if-else a operador ternario

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
Me estoy quedando "O"solo para tener una "O" en el 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)
zzzzBov
fuente
@Joey, ese es en gran medida el punto.
zzzzBov
@Joey, leí en el meta del codegolf que uno debería evitar responder su propia pregunta por algún tiempo para alentar a otros a probar diferentes enfoques. Mi plan era descomentarlo en un día o dos.
zzzzBov
@Joey, no estaba trabajando en mi propia máquina en ese momento, y no tenía ganas de enviarme la respuesta por correo electrónico cuando podía publicarla en un comentario.
zzzzBov
@Joey: "Solo hay cinco de esos" está mal. Cualquiera puede sugerir una edición. Simplemente haga clic en "editar" entre "enlace" y "bandera" y podrá ver el código.
John
@zzz: "ese es en gran medida el punto" Cualquiera puede verlo. Cualquiera puede sugerir una edición haciendo clic en "editar" entre "enlace" y "bandera", lo que abrirá el diálogo de edición, revelando su código.
John
7

GolfScript, 63 caracteres

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

¿Qué, todavía no hay entrada de GolfScript?

Este usa un solo literal numérico 0y una variable llamada O(que se usa para almacenar el número 3). Todo lo demás es aritmética y manipulación de pila. La cadena Hello World!se construye a partir de sus códigos ASCII, carácter por carácter.

Así es 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
Ilmari Karonen
fuente
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!'

Versión más larga sin bucle, 389 bytes:

+++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.+++++++++++++++++
++++++++++++.+++++++..+++.-------------------
---------------------------------------------
---------------.+++++++++++++++++++++++++++++
++++++++++++++++++++++++++.++++++++++++++++++
++++++.+++.------.--------.------------------
---------------------------------------------
----.-----------------------.
Miguel
fuente
Este es un rompecabezas de código de golf, el objetivo es hacer el programa más corto posible. Parte de eso implica publicar la longitud de su código.
zzzzBov
5

Lua 144 97 86 caracteres

Un enfoque diferente, basado en el hecho de que las teclas de la tabla también son cadenas, y el hecho 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

Solución 145 char

  • sin cadenas excepto "O" o 0
  • sin expresiones regulares
  • sin funciones preconstruidas

Hizo la codificación delta de los bytes, luego algunos números primos, etc., etc. :)

Versión de golf:

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

Editar: se cambiaron varias cadenas O y se encontraron algunas optimizaciones más.

jpjacobs
fuente
"O" * - Creo que el * fue para la nota al pie, no "cualquier número de O"
RomanSt
Bueno, regex'ing es lo que hago naturalmente: p. Podría sustituir a costa de 5 ó 3 caracteres adicionales para, respectivamente, la primera y la segunda solución
jpjacobs
Pero de todos modos, los
editaré
Hello y World in table constructor siguen siendo literales de cadena, eso es solo un azúcar sintáctico.
Oleg V. Volkov
5

Pitón ( 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])
Hoa Long Tam
fuente
El literal ''no está permitido.
RomanSt
1
@romkyns: Muy cierto, arreglado.
Hoa Long Tam
55
No arreglado (salida incorrecta). Probablemente estés 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

Me divertí demasiado con este, y aprendí un poco más de J para arrancar. Además, ooo ooo ooopuede ser el código más estúpido que he escrito.

Jesse Millikan
fuente
5

QR con medios bloques (169) 121 caracteres

Con código QR utilizando caracteres UTF-8 de medio bloque:

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

Desafortunadamente, esto no se verá bien allí. Hay un pequeño fragmento con la hoja de estilo apropiada, pero ... ¡No! ¡El lenguaje presentado aquí no es HTML! El idioma presentado aquí es el código QR ! (¡HTML y CSS se usan aquí solo para evitar errores de presentación!)

QR con semibloques (169)

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

Idealmente, esto podría verse así:

QR: Hola Mundo!

F. Hauri
fuente
Use su teléfono inteligente para ver esto o zbardebajo de Linux. (muestra: xwd | xwdtopnm | zbarimg /dev/stdin)
F. Hauri
¿No es Code golf!un personaje literal?
ugoren
2
De hecho, creo que esta respuesta, aunque creativa, no califica porque no es un programa. QR es una forma de codificar datos, no un lenguaje de programación.
ugoren
1
Además, ¿qué pasa con los idiomas como postscript, svgu otros idiomas de presentación ya utilizados allí? Una forma de codificar es un lenguaje de todos modos ... ¡creo!
F. Hauri
1
Usé HTML (menos JS) como ejemplo de lo que no es un lenguaje. Lo mismo vale para QR. Ver estos criterios .
Ugoren
4

Scala ( 357 423 361 caracteres)

Desafortunadamente, no es la respuesta más corta, pero espero obtener puntos de bonificación por el mayor uso 'O'y'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)}

Previamente:

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

Versión antigua (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}}
Gareth
fuente
Creo que la cadena vacía ( "") y las cadenas / literales de caracteres que contienen el carácter cero ( '0') no están permitidos. Solo la cadena "O"(O mayúscula) y el número 0son.
Timwi
Tío. Se requiere algo de edición entonces ...
Gareth
4

C (o C ++) (segmento del cuerpo: 49) (trampa)

Al compilar, compilar a un binario llamado Hello\ World\!, el código es:

#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);
}

El strrchrsegmento es necesario para eliminar la ruta completa en caso de que el nombre del programa pasado contenga la ruta completa, tampoco se deben pasar argumentos .

La línea de compilación típica podría ser: gcc -o Hello\ World\! foo.c

Nim
fuente
3

C ++, 141, 146

La primera vez que intente uno de estos, probablemente se pueda mejorar bastante todavía:

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:

Robé el truco de división de otra publicación, no puedo creer que no haya pensado en eso :(

LorenVS
fuente
1
Técnicamente se supone que debe incluir todo el programa de trabajo en el recuento de caracteres, incluidos elementos como main, cualquier biblioteca incluida 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

Supuse que la coincidencia de patrones le daría a Haskell una gran ventaja, en particular porque puedes inicializar poderes de dos de esta manera:

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

Sin embargo, como se ve en la respuesta Haskell de MtnViewMark (que, por cierto, merece muchos votos a favor) y otras respuestas, se puede lograr una mejor compresión usando más que solo +y -.

Joey Adams
fuente
3

Clojure - 46 caracteres

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

Tenga en cuenta que Helloy World!son símbolos, no literales de ningún tipo.

mikera
fuente
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);
}
fR0DDY
fuente
1
El 100viola la regla sobre los números. Reemplácelo con algo más divertido.
Joey Adams
@ joey-adams Gracias por señalar. Cambió eso.
fR0DDY
Line 7: error: ISO C++ forbids declaration of 'main' with no type
Nathan Osman
@ george-edison Corregido. Aunque funcionó sin intg ++
fR0DDY
3

PHP - 49 caracteres

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

Registro de cambios :

  • (73 -> 86) Olvidé mostrar un signo de exclamación ... suspiro
  • (86 -> 57) Utiliza una sola variable con incrementos
  • (57 -> 51) Cambiado para usar operadores bit a bit en 0
  • (51 -> 49) Más operadores bit a bit
nyuszika7h
fuente
1
Estoy bastante seguro de que las constantes contarían como literales de cadena debido a las conversiones.
Kevin Brown
@ Bass5098 ¡Gracias por tu edición! Lo aprobé
nyuszika7h
@ Bass5098 que no funciona, necesita tener caracteres 32 y 33, no 21 y 22. <?$a=-~-~-~0;echo Hello.chr($a.$a-1).World.chr($a.$a);funciona, pero son 54 caracteres.
zzzzBov
@zzzzBov No pude descubrir cómo borrar la edición inicialmente, y olvidé revertirla una vez que fue aprobada.
Kevin Brown
Vaya, dejé el 1allí. Ahí voy rompiendo mis propias reglas ... <?$a=-~-~-~0;echo Hello,chr($a.~-$a),World,chr($a.$a);es lo que debería haber usado, todavía 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,_])
flornquake
fuente
Use '' (sin espacio anterior) en lugar de str ()
aditsu
2
Además, muy agradable! :) Por cierto, la asignación múltiple no está ahorrando ningún carácter
aditsu
@aditsu: No puedo, eso sería un literal de cadena. Gracias por tus comentarios. :)
flornquake
Oh vaya, de alguna manera la cadena vacía no se registró como un literal en mi 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 personaje se imprime a través de su número ordinal, que es la longitud de una matriz. La construcción de las matrices se optimiza mediante la representación binaria de los números de caracteres.

Sin golf:

@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
Heiko Oberdiek
fuente
parece que mi vudú binario te inspiró :) +1
masterX244
3

Java 389 caracteres

vio una declaración innecesaria

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),_});}}

La historia está en el historial de edición ahora, la versión original sin golfing legible:

// 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
    }
masterX244
fuente
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**@_})

(se agregan nuevas líneas para reducir el ancho, pero son innecesarias, por lo que no se cuentan)


Hello World! está codificado como una lista de listas de las potencias de 2 de cada letra.

Hay exactamente un lugar donde tengo un literal 0que se usa para cualquier cosa que no sea a 0. Se utiliza para crear una lista de un elemento, que se convierte inmediatamente en el número 1con el operador de prefijo 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**@_})
Brad Gilbert b2gills
fuente
3

JavaScript 662 caracteres

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

¿Qué pasa con el abuso de los literales de matriz solo para tener una base unaria? Este programa tiene la ventaja de no usar 0.

Konrad Borowski
fuente
Si bien esto puede ser válido, este rompecabezas en particular es un código de golf, lo que significa que debe apuntar al código más corto posible. Con más de 600 caracteres, no estás cerca de los <100 caracteres que las soluciones JS existentes ya tienen.
zzzzBov
1
@zzzzBov: en realidad no estoy tratando de ganar.
Konrad Borowski
1
Este programa tiene la ventaja de no usar 0. ¿Qué hay de O_O=0;?
Erik the Outgolfer
@EriktheGolfer: Corregido, gracias. No pude notar eso.
Konrad Borowski el
O_O=[].lengthse puede escribir como O_O=falseque lo disminuye en 4.
Atmocreations