Hello World más corto ordenado

27

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.

Pasatiempos de Calvin
fuente
77
Es un poco tarde ahora, pero de alguna manera siento que menos líneas y menos bytes podrían haber sido más interesantes ...
Sp3000
66
@ Sp3000 Necesitaríamos una medida combinada, de lo contrario, Unary y Lenguage significarían que solo 1-liners podrían competir.
isaacg
@ Sp3000 Quizás, solo quería asegurarme de que Unary / Lenguage no ganara. Sin embargo, estoy abierto a cambiarlo (lo siento, Isaac). Comenta el comentario de Sp si estás de acuerdo.
Hobbies de Calvin
@ Sp3000 He tomado tu consejo. Ver actualizaciones
Calvin's Hobbies
¿Se puede invertir el orden? Por ejemplo, ¿leer de izquierda a derecha?
Ismael Miguel

Respuestas:

17

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))
Sp3000
fuente
Eso fue inteligente! +1
theonlygusti
¿Podría usar un programa BF más corto, o el programa está construido de una manera específica por alguna razón? Probé el programa BF que utilicé en su generador, pero la salida incluía algunos Unicode.
mbomb007
1
@ mbomb007 El problema con los programas BF más cortos es que incluso este método ingenuo termina en el punto de código 124, por lo que no creo que haya suficiente margen de
maniobra
30

/// , 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.

Martin Ender
fuente
19
Ni siquiera me di cuenta de que las URL podrían contener tantas barras en una fila.
Alex A.
44
@AlexA. Me llevó meses poner a funcionar esa URL, IIRC. Tuvimos que cambiar el nombre del artículo para tratar los cambios en la configuración del servidor y la configuración de MediaWiki.
17

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.

kennytm
fuente
2
¡Absolutamente brillante! Seguro que no sé si es posible usar el mismo tiempo de estrategia en Python (distingue entre mayúsculas y minúsculas).
mbomb007
¡Muy agradable! Tenga en cuenta que =Z[3*7]se puede escribir como =Z[~-22]que solo necesita un salto de línea en lugar de dos.
Yo y mi gato
@ mbomb007 Sí, pero los espacios son y son los primeros en el conjunto ASCII ...
Harry Beadle
@meandmycat Gracias! Actualizado.
kennytm
13

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.

n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
fuente
11

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.

n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
fuente
No estoy seguro si son 17 o 16 líneas (hay una nueva línea al final), pero de cualquier manera, esto no va a ganar nada.
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
Ganaste 10 votos a favor, eso ya es mucho. ¡Los más votados (a partir de ahora) tienen 12 votos a favor! Y la solución /// con 23 votos a favor.
Ismael Miguel
11

> <> , 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
\^
Sp3000
fuente
2
En el segundo código, puede guardar 2 bytes gracias al
ajuste
10

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

Sp3000
fuente
8

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

randomra
fuente
No es una solución válida; 6535529689086686142930090 no está ordenado.
theonlygusti
@theonlygusti "El código es extremadamente largo, interpreta [6535529689086686142930090 '+' signs]y [6535529689086686142930090 'd' characters]literalmente en la primera línea del código". (Si no está claro lo que quiere decir con que el registro de la segunda pieza de código.)
randomra
¡Ah, vale! Lo siento, tonto: PI lo tomó literalmente.
theonlygusti
2
El tamaño es de 13 YB, aproximadamente 1000 veces el tamaño de Internet.
Charles
@ Charles obtengo ~ 40YB incluyendo las últimas líneas.
Veedrac
8

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.

Ismael Miguel
fuente
1
La salida en el navegador es Hello , Wor l d !. Tenga en cuenta los espacios adicionales! Esta no es una respuesta válida, desafortunadamente.
CJ Dennis
1
Probado en Firefox 36, IE 8, Opera 12.17 y Opera 28 (Chromium) en Windows XP. Todos representaron la salida de forma idéntica. Dado que cualquier número de caracteres de espacio en blanco se representa como un solo carácter de espacio (sin restricción de espacio de descanso, etc.) cada nueva línea se convierte en un espacio. ¡Me interesaría saber si algún navegador representa su salida sin espacios!
CJ Dennis
1
Buen abuso del idioma! Dado que los errores que genera técnicamente van a stderr y no a stdout, su código ahora es válido, ¡aunque en mi caso veo muchos errores en mi navegador! ¡Y, increíblemente exigente, mi configuración de PHP tiene etiquetas cortas desactivadas, por lo que la primera línea de mi computadora <?phpes inválida! Sin embargo, ¡te perdonaré por esto! OK, acabo de probar <?Phpqué funciona, ¡así que acabo de enterarme de que la etiqueta de inicio no distingue entre mayúsculas y minúsculas!
CJ Dennis
1
Las dos soluciones principales en esta respuesta no siguen las reglas. El superior tiene, como la línea 8,. "!<br- Esto no está ordenado. El segundo tiene como línea 10: ."!- no ordenado.
skagedal
1
@IsmaelMiguel Lo siento, pero no. La línea 7 de la primera sugerencia no está ordenada. Las líneas 5 y 7 de la segunda sugerencia no están ordenadas.
skagedal
7

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í

isaacg
fuente
@orlp Agregué cadenas multilínea hace unos días, y Pyth ha tenido soporte para nuevas líneas en la entrada durante siglos. Esto no usa el modo multilínea en absoluto. Pruébelo en el compilador en línea, que definitivamente no tiene modo multilínea.
isaacg
2
Es casi lo mismo en CJam, con el mismo recuento de bytes también.
Optimizador
4

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
mbomb007
fuente
Las Emitlíneas no funcionan, ya que i(105) es menor que m(109).
bcsb1001
Debería ser "EMit", entonces?
skagedal
4

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:

Representación visual de la fuente anterior.

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

es1024
fuente
2

Perl, 17 líneas

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

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!

draegtun
fuente
Su programa no es válido, {no puede ser antes de cualquier letra.
theonlygusti
@theonlygusti - Solucionado (pasó de 9 líneas a 13). La única línea que me causó un problema fue {,}. Esto es ahora Sp + 12(más de 3 líneas) que es equivalente al carácter de espacio + 12 (es decir, coma)
draegtun
2

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

mbomb007
fuente
2

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!^^!
carne sin carne
fuente
1

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.

histocrat
fuente
0

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

mbomb007
fuente