Escriba un programa que no tome datos e imprima Hello, World!en stdout o la alternativa más cercana a su idioma. El problema es que cada línea en su programa solo debe contener caracteres ASCII imprimibles y debe estar en orden lexicográfico, también conocido como ordenado.

Aquí están todos los 95 caracteres ASCII imprimibles en orden:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Entonces, por ejemplo, la línea !!A0~sería inválida porque Ay 0están fuera de servicio. La línea !!0A~sería válida.

Cada línea en su programa puede tener cualquier longitud y puede haber cualquier número de líneas. Las líneas vacías se consideran ordenadas. Cada una de las nuevas líneas en su programa debe ser la misma (sin mezclar \ny \r\n). Las pestañas y otros caracteres ASCII no imprimibles están prohibidos.

Debido a la demanda popular , la condición ganadora ha cambiado:
la presentación con la menor cantidad de líneas gana. Tiebreaker va al programa más corto (las nuevas líneas cuentan como caracteres individuales).

Solo se Hello, World!debe generar una nueva línea final opcional. Tenga en cuenta que HQ9 + no es válido ya que sale hello, world. Puedo prohibir idiomas similares a HQ9 + que tengan un carácter "¡Hola, mundo!" comandos debido a su trivialidad.

Insinuación:

Esto es definitivamente posible en Unario y Idioma , aunque no muy concisa.

Headsecks , 1 línea, 366 bytes

                                                                        $(((((((((((((((((((((((((((((,000000044888<AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIIIIIIIIIIIILPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPTXXXXXXXXXXXXXXXXXXXXXXXX\```diiiiiilqqqqqqqqtyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy|

Headsecks es una sustitución trivial de Brainfuck donde lo único que importa es el módulo de punto de código 8. El Brainfuck equivalente es simplemente

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

Afortunadamente, este enfoque ingenuo simplemente encaja. Hay algún potencial para jugar golf en bytes, pero puede ser difícil.

Probado con este intérprete de Python .

Generando código

code = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------.------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.------.--------.-------------------------------------------------------------------."
command_map = "+-<>.,[]"

last_point = 32
out = []

for char in code:
    curr_mod = command_map.index(char)
    last_mod = last_point % 8

    if curr_mod > last_mod:
        last_point += curr_mod - last_mod

    elif curr_mod < last_mod:
        last_point += (8 - last_mod) + curr_mod

    out.append(chr(last_point))

print("".join(out))

/// , 7 líneas, 22 bytes

/
//Hello
,
 Wor
l
d
!

Una rara oportunidad para que /// sea competitivo (siempre y cuando nadie comience con Unary y Lenguage ...).

El código primero encuentra a /, y analiza el

/
//

como una instrucción de sustitución que elimina todas las líneas nuevas del resto del programa. Luego, el programa simplemente lee

Hello, World!

que se imprime textualmente ya que no contiene más barras.

JavaScript (67 66 62 líneas, 227 269 ​​bytes)

(Nota: solo probado en Firefox 36 y Safari 8, contiene características menores de ES6 (la Setclase))

Z
=
!""+
(0[[]]
+
(
!!""+Set
));c
=Z[~
-22]
$=Z[
3]
$$=Z[
15]
$$$=Z[
24]
$$$$=Z[
1]
$$$$$=Z[
0]
Set
[c
+
$$$+Z[
5]
+Z[
16]
+
$$$$$+
$$$$+Z[
2]
+c
+
$$$$$+
$$$+
$$$$]
(Z[
14]
+
$$+
$+
$$$$+
$$$$$+
"(\
'H\
"+
$+
$$+
$$+
$$$+
",\
 W\
"+
$$$+
$$$$+
$$+Z[
6]
+
"\
!')\
")
()

El código anterior básicamente hace:

alert("Hello, World!")

Obviamente alertno está ordenado. Por lo tanto, debemos generar la declaración como una cadena y "evaluarla":

s = "alert('Hello, World!')";   // generate this using sorted code
eval(s)

¿Cómo generar la cadena? ES5 admite la continuación de línea para que

"AL\
ERT" === "ALERT"

Pero el código de caracteres \aparece antes de todas las letras minúsculas, por lo que tenemos que generar las letras minúsculas utilizando otros métodos.

Tomamos prestada alguna idea de JSFuck aquí. Las letras minúsculas involucradas en las declaraciones de alerta son:

t e r a o l d

Todo esto se puede extraer de los caracteres de los objetos estándar, que se pueden expresar en términos de una secuencia ordenada:

t, e, r ← true      = !""
a, l    ← false     = !!""
o       ← function  = Set
d       ← undefined = 0[[]]

¿Cómo evaluamos la cadena? Seguramente no podemos usarlo eval(s)ya que no está ordenado. Alternativamente, podríamos usar Function(s)(), pero no podemos usar, Functionya que tampoco está ordenado. Sin embargo, Functiones el constructor de todas las funciones, lo que significa Set.constructor === Function.

Al agregar el identificador, constructorla lista de letras minúsculas se convierte en:

t e r a o l d c u n s

que afortunadamente aún podría ser generado por "truefalseundefinedfunction":

t, e, r, u ← true      = !""
a, l, s    ← false     = !!""
o, c, n    ← function  = Set
d          ← undefined = 0[[]]

Después de la prettificación, el código anterior debería leer como:

// lines 1~8 defines our string containing all lowercase letters we want
Z = true + (undefined + (false + Set))
// Z = "trueundefinedfalsefunction Set() { [native code] }"

// lines 8~20 defines the variables `c`, `$` (e), `$$` (l), `$$$` (o), 
// `$$$$` (r), `$$$$$` (t)
// for the corresponding lowercase letters extracted from `Z`

// the rest calls:
Set["constructor"]("alert('Hello, World')")()
// lines 22~36 generates the "constructor" string
// lines 37~61 generates the "alert('Hello, World')" string

Actualización: Ahora se llama E, L, O, R, Ta varios repetición de $reducir 4 líneas.

Insomnio , 4 líneas, 59 bytes

 FFFFGjnnnnooty
FLLddeejkopqyyyyy~~
(<ddjnoppppqrtu
<<Fddfj

Este programa se genera al optimizar el recuento de líneas.

10 líneas, 43 bytes

(u
pt
(dppty
p~
j
<Fptt{
(otz
?o
FLu
<?FFu~

Este programa anterior se genera al optimizar el recuento de bytes.

Cygwin bash, 16 líneas, 60 bytes

Esto solo funciona debido al nombre de archivo que no distingue entre mayúsculas y minúsculas en Windows, y al hecho de que Cygwin busca las utilidades sin distinción entre mayúsculas y minúsculas, incluso si no lo configura para reconocer la ruta entre mayúsculas y minúsculas.

A\
=Hello
A\
+=\
",
"Wor
A\
+=l
A\
+=d
A\
+=\
!
E\
CHO\
 $A

Toma nota de eso ECHOal final.

> <> , 6 líneas, 111 bytes

  """""""/;;Hello
        &\o
      &++\oooo~~
"++++++++\bbbdlr
    +++++\ccccccccfooo}
    $++66\cfffffooooopr

Tengo problemas para jugar una línea extra, pero en cualquier caso estoy feliz de haber superado el método de 7 líneas.

Explicación

> <> es un lenguaje 2D basado en pila donde las instrucciones son caracteres únicos y el flujo del programa puede ser arriba, abajo, izquierda o derecha. La "instrucción alterna el análisis de cadenas, empujando los caracteres hasta que se alcanza un cierre ", pero debido a la naturaleza de> <> no existe el "análisis de cadenas de líneas múltiples" como las cadenas de CJam o las cadenas de triple cita de Python. ¡Esto resultó ser un problema importante porque no está permitido comenzar y terminar una línea con "ay tener otros caracteres intermedios (por ejemplo "some chars")!

Tenga en cuenta eso /y \refleje el flujo del programa, por lo que en realidad ejecutamos la primera línea, luego todas las líneas en orden inverso, ¡y la mayoría de las líneas se ejecutan realmente hacia atrás!

[Line 1]

""""""              Three empty strings, push nothing
"/;;Hello  "        Push "/;;Hello  ". Note the wrapping - ><> is toroidal!
""""""              Three empty strings, push nothing

[Line 6]
66++$               Turn the top " " into "," by adding 12, then swap top two
rp                  Reverse stack and pop top 3
ooooo               Print "Hello", stack is now " ,"
fffffc              Push some 15s and a 12

[Line 5]
+++++               Sum the 15s and 12 to give 87, or "W"
}ooo                Move "W" to the back and output ", W"
fcccccccc           Push a 15 and some 12s

[Line 4]
++++++++            Sum the 15 and 12s to give 111, or "o"
"rldbbb\++++++++"   Push chars to stack
r                   Reverse stack
ld                  Push length of stack and 13, not used
bbb                 Push three 11s

[Line 3]
++&                 Sum the 11s to give 33, or "!" and put in register
~~                  Pop top two
oooo                Print "orld"

[Line 2]
&                   Put "!" from register to stack
o                   Print "!"

[Line 1]
;                   Terminate

En una nota al margen, aquí hay un intento divertido de> <> menos bytes (23 líneas, 47 bytes):

v
"
!
d
l
r
o
W

,
o
l
l
e
H
"
/<
l
?
!
;
o
\^

CJam, 5 4 líneas, 162 bytes

"Hello
")))))))))))))))))))))))))))))))))))68S\cel
"Wor
")))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))@SX\c|

¡El mismo número de líneas que Insomnia! (pero muchos más bytes)

Pruébalo en línea .

Explicación

"Hello\n"        Push "Hello" and a newline
)                Uncons the newline
)))...)))        Increment the newline into a ","
68S\             Push 68 and a space then swap, leaving 68 on top
c                Convert 68 into a char "D"
el               Lowercase "D" into "d"
"Wor\n"          Push "Wor" and a newline
)                Uncons the newline
)))...)))        Increment the newline into an "l"
@                Rotate top three elements, moving the "d" to the top
SX\              Push a space and 1 then swap, leaving the space on top
c                Convert the space (which is an array) into a char
|                Bitwise or the space (32) with 1 to give "!" (33)    

CJam imprime automáticamente la pila después.

Gracias a @Optimizer por recordarme que Scfunciona, porque de lo contrario SX|falla (hace un setwise o, en cambio, da la matriz que consiste en un espacio y 1).

> <> (Pez) , 5 líneas, muchos bytes

¡El código es extremadamente largo, cuando digo [6535529689086686142930090 '+' signs]y [6535529689086686142930090 'd' characters]en la primera línea del código, quiero decir que hay literalmente 6535529689086686142930090signos más en una fila!

(Y para las siguientes líneas agregue los espacios de prefijo necesarios).

'[6535529689086686142930090 '+' signs]^`[6535529689086686142930090 'd' characters]
                                   **,/288
                                     -/:o
                             %**288:;?\
                                   (1:\

Una alternativa comprobable más corta que solo imprime Hi:

'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++^`hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
                                                                                                                               **,/288
                                                                                                                                 -/:o
                                                                                                                         %**288:;?\
                                                                                                                               (1:\

Método:

• En la primera línea creamos un gran número que representa la cadena en base128.
• En el resto de las líneas (de abajo hacia arriba) imprimimos el siguiente carácter en cada bucle hasta que el valor del entero llegue a 0.
• El código de bucle es :1(?;:882**%:o-288**,.

(Podemos imprimir una cadena larga arbitraria de más de 2 caracteres con este método).

PHP (7/17 líneas, 36/59 bytes):

Debido a la cantidad de respuesta no válida, reescribí esta respuesta.

La versión del navegador? Ido.

Pero tengo 2 soluciones, ambas basadas en bitwise xor( ^) de cadenas en PHP.

¡Esta es una solución extremadamente poderosa! A veces, permite guardar muchos bytes.

Primero, la respuesta más corta:

Echo
Hello
,AM^mm
,Wor
,OOO^
"#+n
";

Lo sé, se ve horrible, ¡pero funciona!

El siguiente depende de las nuevas líneas.

¡Sí, usa líneas nuevas ( \nse requiere el estilo / UNIX)!

Echo
Bo
.ff
.e
.
"&*]ex
fn
"^
"\n
\n
\n
\n
\n
\n
\n
",B^c
;

Las nuevas líneas en este se requieren para trabajar.

¡No es perfecto, pero funciona!

Ambas respuestas se basaron en la solución de @ MartinBüttner :

Echo
Hello
.
chr
(44
).
chr
(29
+3
).Wor
.l
.d
."!
";

Un agradecimiento especial a @ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ , @CJDennis , @ MartinBüttner y @skagedal por detectar todos mis errores y por sus sugerencias.

Pyth, 7 líneas, 23 bytes

-
"Hello
,
 Wor
l
d
!"b

Bastante simple, solo use una cadena multilínea y elimine las nuevas líneas.

Pruébalo aquí

Adelante, 41 líneas, 143 bytes

Pruébalo en línea.

Estoy muy orgulloso de esto. Lo saqué bastante rápido una vez que descubrí que podía hacerlo, haciendo que Google buscara idiomas que no distinguen entre mayúsculas y minúsculas, y ya conozco decentemente a Forth. Casi definitivamente se puede acortar, tanto bytes como líneas. Se agradecen las sugerencias. :RE

Este programa esencialmente empuja el valor decimal de cada carácter ASCII, luego imprime cada uno. Intenté optimizar mientras lo escribía, por lo tanto, es menos legible de lo que me gustaría.

33
99
1
+
DUp
8
+
2DUp
6
+
SWap
11
+
2OVer
SWap
8
9
*
EMit
1
+
EMit
DUp
DUp
EMit
EMit
3
+
EMit
29
3
2DUp
+
EMit
*
EMit
EMit
EMit
EMit
EMit
EMit

Maravilloso, 9 líneas, 94 bytes

3333
    @ADD
    358C
++--29\\
++--3555DE
<<<<<<>>~~
+++++446666D
++++++++../\
      ++------

Pruébelo en línea aquí. Using spaces for blank cellsdebe ser verificado

Representación visual de la fuente:

Explicación: Cada valor hexadecimal en este programa se mueve hacia abajo cada "marca" (a menos que esté activado \\, en cuyo caso se mueve hacia la derecha). ++incrementará el valor, --disminuirá, ~~aplicará un bit a bit, etc. Los valores que caen de la parte inferior se imprimen como un carácter ASCII.

Por ejemplo: Se 33convierte en en la esquina superior (((0x33 +1 +1) << 1) +1 +1 = 0x6C (l).

Perl, 17 líneas

$_
=
'pr
int
"Hello
,
 Wor
l
d
!"';s
!
!!g
;s
!.
*
!$&
!eex

Rebol - 15 líneas (51 bytes)

PRin
AJOin
[
'Hello
Sp 
+
12
Sp
'Wor
'l
'd
Sp
+
1
]

Las palabras en Rebol no distinguen entre mayúsculas y minúsculas (por ejemplo PRINT, Printy printtodas llamarían a la misma función).

El código anterior ordenado:

prin ajoin [
    'Hello  sp + 12  sp  'Wor  'l  'd  sp + 1
]

NÓTESE BIEN. spdevuelve el espacio char!

Unario , 1 línea, muchos bytes

Todos los personajes de este programa son 0. La fuente es demasiado larga para poner aquí, pero consiste en una cadena de tantos ceros:

327380789025192647555922325233404088310881092761595127419003295178342329930050528932118548

Esta es la representación decimal para este número binario:

0b1010010010010010010010010110000010010010010110000010010000010010010000010010010000010001001001001011111000010000010000011110001111001011111000000100000011011011100010010010010010010010100100010010010100000000100001011100001100010010010100011011011011011011100011011011011011011011011100000000010100

El cual fue creado a partir de este programa BrainF ***:

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

Vea cómo lo generé : http://ideone.com/lMT40p

Lote - 39 líneas (202 bytes)

Quería reducir el tamaño al permitir la expansión demorada ejecutando el código dentro de una cmdllamada usando el /v oninterruptor, pero no pude pasar todos los quilates.

@S^
ET^
LO^
C^
AL^
 EN^
ABL^
E^
DEL^
AY^
E^
DEX^
P^
ANS^
IO^
N
@S^
ET^
 0=Hello
@S^
ET^
 1=^
,^
 Wor
@S^
ET^
 2=l
@S^
ET^
 3=d
@E^
CHO^
 !^
0^
!!1^
!!2^
!!3^
!^^^
!

Sin las nuevas líneas (y quilates para escapar de las nuevas líneas):

@SETLOCAL ENABLEDELAYEDEXPANSION
@SET 0=Hello
@SET 1=, Wor
@SET 2=l
@SET 3=d
@ECHO !0!!1!!2!!3!^^!

Ruby, 19 líneas, 95 bytes.

$;=
$>
$;<<
:Hello
$;<<
44::chr
$.=
33::
-1
$;<<
$.::chr
$;<<
:Wor
$;<<
:l
$;<<
:d
$;<<
33::chr

Posiblemente la segunda restricción de código más difícil para Ruby que he visto en este sitio, después de la monstruosidad aquí .

Editar para explicación: el único método de salida de Ruby que está ordenado es el <<método en STDOUT. Desafortunadamente, la constante para STDOUT es $>, y >es ASCII más alto que la mayoría de los símbolos, por lo que no es posible llamar a un método. Necesitamos una declaración de asignación de varias líneas para obtener un nombre de variable más manejable $;(el punto y coma sigue siendo bastante alto, pero la mayoría de las variables de esta forma no son asignables o solo pueden ser cadenas).

Los símbolos ( :Wor, etc.) son la forma más fácil de hacer un literal, y no veo una forma de quitar nuevas líneas de una cadena, por lo que necesito varias declaraciones de impresión. El espacio y la puntuación no pueden entrar en un símbolo literal, pero afortunadamente el chrmétodo en números es legal, por lo que puedo obtener un carácter de su valor ASCII. ::es una forma alternativa de llamar a los métodos. El espacio es complicado porque no puedo escribir 32, así que resta 1 de 33 y lo asigno a una variable.

Retina, 12 líneas, 29 bytes (no competitiva)

El lenguaje es más nuevo que el desafío.

Hello
$
,
$
 Wor
$
l
$
d
$
!

Pruébalo en línea