Su objetivo es escribir "¡Hola, mundo!" (menos las comillas). Este es un concurso de popularidad , por lo que gana la mayoría de los votos. La longitud del código se usará para romper los lazos.
Todo vale, siempre que esté dentro de las siguientes reglas:

• Todos los caracteres deben ser letras o números, por lo que solo puede usar caracteres en la cadena "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".
• Todo el código que use debe estar en un archivo, con la excepción de los módulos / clases importados / como se llamen en su idioma favorito.
• Solo se permiten las bibliotecas / marcos estándar para el idioma de su elección (por ejemplo, el módulo Math de Python está permitido, pero Numpy, Scipy y Pygame no lo están). Permitiré TkInter ya que es el estándar de facto para GUI en Python.
• No se permite la entrada, ya sea leyendo desde stdin, leyendo un archivo, mostrando una imagen o leyendo desde la web.

+10 puntos de brownie si descubres cómo hacerlo en Java sin doblar las reglas.

En tus marcas, prepárate, código!

EDITAR: se permiten llaves ({}), corchetes ([]) y paréntesis (()) ya que esto sería prácticamente imposible para la mayoría de los idiomas sin ellos. También estoy eliminando la regla de límite de caracteres. Esperemos que esto lo haga más interesante.

EDITAR ^ 2: el espacio en blanco también está permitido. Mi cerebro no funciona correctamente, lo siento. >. <

Perl

Algunos dicen que Perl es un lenguaje lleno de ruido ascii y símbolos aleatorios como $... Eso no es cierto: P

s zzHelloq worldmz and s zqzchr 44ze and s zmzchr 33ze and print

Dividamos esto en subexpresiones:

(s zzHelloq worldmz) and (s zqzchr 44ze) and (s zmzchr 33ze) and (print)

Debería ser obvio que se ejecuta de izquierda a derecha siempre que cada expresión devuelva verdadero. ¿Pero qué demonios es s zqzchr 44ze?

En Perl, hay un grupo de "cotización similar a los operadores" que incluye q(str), qw(li st), /regex/, s/from/to/entre otras cosas. Resulta que todos estos operadores pueden usar casi cualquier carácter como delimitador, con un par de particularidades: la paréntesis de apertura debe cerrarse mediante un paréntesis de cierre coincidente, y si desea utilizar una letra como delimitador , debe poner un espacio después de la letra del operador (para eliminar la ambigüedad de una palabra simple).

En este caso, vemos tres usos del s///operador (sustitución de expresiones regulares):

s//Helloq worldm/
s/q/chr 44/e
s/m/chr 33/e

Todo delimitado por el personaje z. El /eindicador en los dos últimos hace que la sustitución se interprete como un código a evaluar, en lugar de texto literal.

Un hecho bastante conocido sobre Perl es que la mayoría de las operaciones por defecto funcionan en la $_variable incorporada a menos que se especifique lo contrario. Todas estas tres sustituciones y la printoperación $_en este caso, por lo que primero colocamos las palabras Hola mundo en la variable, luego arreglamos la puntuación usando los valores ascii numéricos de los caracteres, luego imprimimos el contenido de la variable.

do

int main(void) {
  if (putchar(72))
    if (putchar(101))
      if (putchar(putchar(108)))
        if (putchar(111))
          if (putchar(44))
            if (putchar(32))
              if (putchar(87))
                if (putchar(111))
                  if (putchar(114))
                    if (putchar(108))
                      if (putchar(100))
                        if (putchar(33)) 
                        {
                        }
}

(editar - BBC basic se movió a una respuesta separada como se sugiere. La mayoría de los votos sobre esto son definitivamente para la respuesta LOGO).

LOGO

Intérprete en http://www.calormen.com/jslogo/#

TO h        pd  fd 100 rt  90  pu  fd 50  rt 90  pd  fd 100  rt 180 fd 50  lt 90  fd 50  rt 90  pu END 
TO e        pu  fd 25  rt  90  pd  fd 25  rt 90  arc 270 25  lt 90  fd 25  lt 90  pu END  
TO l        pd  fd 100 pu  END  
TO o        rt  45 fd  35  pd  arc 360 25  lt  45  pu END 
TO comma    pd  rt 90  arc 90  15  lt  90  pu END 
TO w         l  rt 180 l   pd  lt  135 fd  35  rt  90  fd 35  lt 135  l  END  
TO r        pd  fd 25  rt  90  pu  fd  25  rt 180  arc 180 25 rt 90 END 
TO d         o  rt 135 fd  35  lt  135  l  END      
TO exclaim arc 360 5   fd  10  l  END 

clearscreen  
setpencolor 4 pu 
setxy 0 150      h 
setxy 100 150    e  
setxy 200 150    l 
setxy 250 150    l 
setxy 300 150    o 
setxy 350 150    comma  
setpencolor 1 
setxy 0 0        w 
setxy 100 0      o 
setxy 200 0      r  
setxy 300 0      l 
setxy 350 0      d 
setxy 450 0      exclaim 
fd 100

Salida (el triángulo verde es el cursor de tortuga)

Applescript

No hay paréntesis [], llaves {}ni paréntesis ()en este caso:

set s to ASCII character 72
set s to s as list
set end of s to ASCII character 101
set end of s to ASCII character 108
set end of s to end of s
set end of s to ASCII character 111
set end of s to ASCII character 44
set end of s to space
set end of s to ASCII character 87
set end of s to item 5 of s
set end of s to ASCII character 114
set end of s to third item of s
set end of s to ASCII character 100
set end of s to ASCII character 33
display dialog s as text

Salida es:

Golpetazo

Este tipo de trabajo, si entrecierra los ojos:

echo NN i NN i i i iNN NNi i i i i i i NN i NN i i i i i i i NNi i i NN NN
echo NN i NNi i i i NN NN i i i i i i iNN i NN i i i i i i i NN i i iNN NN
echo NN i NN iNNNNi NN NN iNNNNi i i i NN i NN iNNNNi NN NN iNN iNNN NN NN
echo NNNNNNN NN iNN NN NN NN iNN i i i NN i NN NN iNN NNN iN NN NN iNNN N
echo NN i NN NNNNNN NN NN NNi NN i i i NN N NN NNi NN NN i i NN NNi iNN N
echo NN i NN NN i i NN NN NN iNN i i i NNN NNN NN iNN NN i i NN NN i NN
echo NN i NN iNNNi iNN NN iNNNNi N i i NN i NN iNNNNi NN i i NN iNNNN N NN
echo i i i i i i i i i i i i i i N

base64

SGVsbG8sIFdvcmxkIQ

Satisface las reglas originales.

Pitón

Entonces, ¿qué, asumimos que todos leen horizontalmente? Para aquellos usuarios que les gusta leer verticalmente:

print chr(72) 
print chr(101)
print chr(108)
print chr(108)
print chr(111)
print chr(44)
print chr(32)
print chr(87)
print chr(111)
print chr(114)
print chr(108)
print chr(100)
print chr(33)

Polyglot: HQ9 +, H9 +, HQ9 ++, CHIQRSX9 +, HQ9 + B y HQ9 + 2D (1 byte)

H

Gracias @victor por la lista de idiomas.

OMGROFL

Soy un gran admirador de los lenguajes esotéricos. Afortunadamente, OMGROFL es alfanumérico:

lol iz 72
rofl lol
lol iz 101
rofl lol
lol iz 108
rofl lol
rofl lol
lool iz 111
rofl lool
loool iz 44
rofl loool
loool iz 32
rofl loool
loool iz 87
rofl loool
rofl lool
lool iz 114
rofl lool
rofl lol
lol iz 100
rofl lol
lol iz 33
rofl lol
stfu

El izcomando establece un valor en una variable, en este caso lol,lool y looolsirve como variables ...

los rofl comando repite el ASCII equivalente al número almacenado en la variable.

El stfucomando termina el programa;)

COBOL

   ID DIVISION 
   DATA DIVISION 
   01  HELLOWORLDBINARY 
       05  HE                       COMP    PIC 9999 
       05  LL                       COMP    PIC 9999 
       05  OCOMMA                   COMP    PIC 9999 
       05  SPACEW                   COMP    PIC 9999 
       05  ORTEXT                   COMP    PIC 9999 
       05  LD                       COMP    PIC 9999 
       05  EXCLAMATION              COMP    PIC 9999 
   01  FILLER REDEFINES HELLOWORLDBINARY 
       05  HELLOWORLDTEXT                   PIC XXXXXXXXXXXXX
       05  FILLER                           PIC X 
   PROCEDURE DIVISION 
       MOVE 51333                   TO HE 
       MOVE 37779                   TO LL 
       MOVE 38507                   TO OCOMMA 
       MOVE 16614                   TO SPACEW 
       MOVE 38553                   TO ORTEXT 
       MOVE 37764                   TO LD 
       MOVE 23104                   TO EXCLAMATION 
       DISPLAY HELLOWORLDTEXT 
       GOBACK 

Se requieren algunos cambios para convertirse en una fuente verdaderamente alfanumérica únicamente.

PROGRAM-ID se puede descartar. Obtiene un nombre de programa generado (ver mensajes).

ALMACENAMIENTO DE TRABAJO se puede dejar caer. Nuevamente el compilador gime.

Dado que a estas dos líneas les faltaban puntos completos / períodos, que ya no son relevantes ahora que faltan por completo las descripciones, el número de mensajes de error es el mismo que antes y aún no afecta el código generado para el programa.

Al cambiar COMP-5 a COMP, las cláusulas VALUE ya no están permitidas, ya que COMP 9999 tiene solo cuatro dígitos decimales, mientras que COMP-5 es un binario de dos bytes con todos los valores de bits disponibles.

Los valores en los MOVE son los valores decimales que dan los valores binarios que dan los pares de caracteres.

Aunque los campos COMP tienen cuatro dígitos y no permiten cláusulas VALUE con más de cuatro dígitos, puede usar más dígitos en el MOVE de un valor literal sin truncamiento en ese punto ... no me pregunte por qué. La opción del compilador DIAGTRUNC (que he desactivado) producirá diagnósticos de advertencia para estos.

La opción de compilador TRUNC (BIN) podría usarse para tratar COMP como COMP-5, pero los MOVE son otra forma de hacerlo.

Como es COBOL, la salida debe estar en MAYÚSCULAS (una mentira, pero solo por diversión).

HELLO WORLD!

OK, cedido, ahora produce:

Hello, World!

Lo cual, al ser un número impar de caracteres, requirió algunos cambios adicionales, ya que no podemos tener campos binarios de números impares con este compilador. ¡Mira esa línea de 13 X! Normalmente se escribiría como X (13), pero puede ser como he mostrado ...

Y ORTEXT es necesario (o no OR, de todos modos) como nombre porque OR es una palabra reservada para el compilador (significa OR, por supuesto).

Estos son valores EBCDIC, no ASCII, ya que se ejecuta en un cuadro compatible con EBCDIC y Big Endian.

Oh, COBOL requiere muchas paradas completas / períodos. Los dejé fuera (están prohibidos), así que recibí muchos mensajes de compilación. Acabo de decirle al compilador que genere el código de todos modos (ninguno de los mensajes está relacionado con el código objeto).

Incluso sin DIAGTRUNC, los mensajes ahora son hasta 17 ...

  1  IGYDS1003-E   A "PROGRAM-ID" paragraph was not found. 
  Program-name "CBLNAM01" was assumed. 

  2  IGYDS1082-E   A period was required.  A period was assumed 
  before "DATA". 

  3  IGYDS1082-E   A period was required.  A period was assumed 
  before "01". 

                   Same message on line:     11 

  3  IGYDS1040-E   A data item was found in the "DATA DIVISION" 
                   before a section header was encountered. 
                   "WORKING-STORAGE SECTION" was assumed. 

  4  IGYDS1082-E   A period was required.  A period was assumed 
  before "05". 

                   Same message on line:      5      6      7      8
                   9     10     12     13 

 14  IGYDS1082-E   A period was required.  A period was assumed 
 before "PROCEDURE". 

 15  IGYPS2145-E   A period was required.  A period was assumed 
 before "MOVE". 

 23  IGYSC1082-E   A period was required.  A period was assumed 
 before "END OF PROGRAM". 

Ruby (usando solo alnums y espacios en blanco)

putc 72
putc 101
putc 108
putc 108
putc 111
putc 44
putc 32
putc 87
putc 111
putc 114
putc 108
putc 100
putc 33

Salida: Hello, World!

Javascript

with (function SGVsbG8sIFdvcmxkIQ(){}) atob(name)

Use la consola del navegador para probar.

JavaScript

with (String) with ([]) {
    push(fromCharCode(72))
    push(fromCharCode(101))
    push(fromCharCode(108))
    push(fromCharCode(108))
    push(fromCharCode(111))
    push(fromCharCode(44))
    push(fromCharCode(32))
    push(fromCharCode(87))
    push(fromCharCode(111))
    push(fromCharCode(114))
    push(fromCharCode(108))
    push(fromCharCode(100))
    push(fromCharCode(33))
    alert(join([]))
}

FERNANDO

h E R
e I S
h E
l L O
w O
r L
d U S
i N G
o N L
y L E
t T E
r S

H e L L o W O R
L d h E L l O w
O r l D h e L L
O w o R l d H E
L l o W o r l d
H E l L o w O R
L D h E L L O W
O r L d H e l l
O w o R l d h e
L l o w O R l D
H e l L o w O R
L d h E L l O W
O R l D H E L l
O w O
r L d

Rebol

Solución alfanumérica única:

prin quote Hello prin add space 12 prin space prin quote World print add space 1

Arriba hay una actualización que utiliza la excelente sugerencia del Dr. Rebmu add space 1(que produce !) para llegar a todos los personajes.

A continuación se muestra la versión original:

prin quote Hello prin pick mold system 264 prin space prin quote World print pick mold system 12

Versión más corta con soportes:

print rejoin [quote Hello pick mold system 264 space quote World pick mold system 12] 

E incluso versión más corta con tirantes:

print join {Hello} join pick mold system 264 join { World} pick mold system 12

Y la versión más corta con brackets y brackets:

print rejoin [{Hello} pick mold system 264 { World} pick mold system 12]

Rebol usa llaves {}para las citas de varias líneas. Tan completamente válido bajo cambios de reglas, pero no del todo en mi espíritu (en mi humilde opinión) como mis dos primeras respuestas anteriores.

NÓTESE BIEN. Imprimir el !fue un dolor!

Rebol permite y utiliza caracteres de puntuación de forma rutinaria para nombres de funciones y tipos de datos. Por lo tanto, las opciones como to-char 33o to char! 33no se permitirían según las reglas (a pesar de que estos signos de puntuación no son operadores en sí).

Afortunadamente, encontré una manera descarada al convertir el objeto del sistema Rebol: make object! [...]en una cadena y Cherry lo seleccionó !:)

Actualización: Y ahora también la cereza eligió una coma del texto de la licencia en el objeto del sistema.

do

Utiliza solo caracteres alfanuméricos, espacios y llaves {}, corchetes [] y paréntesis ().

main()
{
        if(printf((long long []){0x202c6f6c6c6548}))
                if(printf((long long []){0x21646c726f57})){}
}

printf () acepta un char * como argumento, pero como no podemos usar comillas ("), escribo la cadena como una matriz larga y larga. Los valores que se ven aquí son cadenas ASCII, en little endian (0x48 = H, 0x65 = e, 0x6c = l, y así sucesivamente). Lo escribí en letra larga [] ya que de esa manera puedo pasar un argumento de 8 bytes y, por lo tanto, usar solo dos llamadas printf () en lugar de cuatro.

BBC BASIC

Emulator en bbcbasic.co.uk

Separado de mi respuesta LOGO.

La manera fácil

Los números a la derecha son solo códigos ASCII. Esto es lo mismo que imprimir. Si se me permitiera una coma, podría hacerlo en una sola línea ( VDU 72,101,108,etc.)

   10 VDU 72
   20 VDU 101
   30 VDU 108
   40 VDU 108
   50 VDU 111
   55 VDU 44
   60 VDU 32
   70 VDU 87
   80 VDU 111
   90 VDU 114
  100 VDU 108
  110 VDU 100
  120 VDU 33

Una forma más creativa

    5 MODE 6
   10 READ B
   12 WHILE B
   15   PROC1(B)
   16   PRINT
   17   READ B
   18 ENDWHILE
   20 END

REM procedure prints first square on line, 
REM then calls itself recursively with A DIV 2 to print the next
REM VDU 17 tell VDU controller we want to change colour
REM Next line changes background colour. 
REM Then following line VDU 32 prints a space in that background colour.

  110 DEFPROC1(A)
  115 VDU 17
  120 IF A AND 1 THEN VDU VPOS DIV 6 EOR 133 ELSE VDU 128
  125 VDU 32
  130 IF A THEN PROC1(A DIV2)
  140 ENDPROC

REM binary bitmap data for each row, least significant at left
  150 DATA 463221
  160 DATA 332053
  170 DATA 332151
  180 DATA 332053
  190 DATA 2586485
  200 DATA 1048576
  210 DATA 4395895
  220 DATA 4527447
  230 DATA 4526935
  240 DATA 333143
  250 DATA 4420981
  260 DATA 0

Mathematica

Unprotect[Times]
ClearAll[Times]
Print[Hello FromCharacterCode[44] world FromCharacterCode[33]]

corriente continua

DC es casi la herramienta perfecta para el trabajo.

5735816763073854918203775149089P

El Pcomando DC extrae un número de la pila y envía su representación de computadora sin procesar a STDIO. Al ver como 5735816763073854918203775149089 = 0x48656C6C6F2C20576F726C6421, que se representa como 0x21, 0x64, 0x6C... = 'H', 'e', 'l'...en una arquitectura little-endian, sale Hello, World!.

JavaScript!

Y dijeron que no se podía hacer ... ¡Sin operadores de asignación, sin concatenadores, sin comillas! Arghhhh!

No temas ... Porque la fuerza witheres tú ...

function w(x){
    with(document){
        with(String){
            write(fromCharCode(x))
        }
    }
}
w(72)
w(101)
w(108)
w(108)
w(111)
w(44)
w(32)
w(87)
w(111)
w(114)
w(108)
w(100)
w(33)

Output (on browser screen): Hello, World!

Javascript

Actualización: se las arregló para cortar un montón de personajes mediante la introducción de una función Mundial también.

Otra solución de Javascript que escribe en console.log:

function World() { with (World) return name }
function Hello() {}
with (console)
with (String)
with (Hello)
with (name)
with (concat(fromCharCode(44)))
with (concat(fromCharCode(32)))
with (concat(World()))
log(concat(fromCharCode(33)))

Inspirado por esta entrada .

Primero, defino funciones llamadas Hola y Mundo. Esto se usará más adelante.

Entonces comienzo mi cadena de anidadas. Los with (console)y with (String)se utilizan para que luego pueda invocar console.logyString.fromCharCode sin usar un punto.

El plan ahora es construir la cadena Hello, World!abusando de los anidados. Cada vez que invoqué concat (), la cadena resultante será el contexto en el siguiente bloque con. Tomo un atajo para obtener rápidamente "Hello"accediendo a la namepropiedad de la Hellofunción. Luego concateno los caracteres de coma y espacio usandoString.fromCharCode .

El siguiente truco es conseguir el "World" parte de la cadena. No puedo usar el mismo método que solía obtener Hello, ya que no puedo invocar World.name. En cambio, pongo esa lógica dentro del método World, y la invoco.

Finalmente, agrego el signo de exclamación final y envío el resultado directamente a la función de registro, que por supuesto es console.log.

Perl

En un Perl moderno (5.10 o más reciente):

print q{Hello} and print chr 44 and print q{ World} and say chr 33

En Perl mayor:

print q{Hello} and print chr 44 and print q{ World} and print chr 33 and print chr 10

Ambas soluciones anteriores utilizan el qoperador tipo cotización Perl y permiten delimitadores selectivos para citar una cadena, por ejemplo. q{} q[] q() q//

Esta solución requiere el cambio de regla que permite llaves, paréntesis o parens. Así, mientras que totalmente válida Creo mniipexcelente respuesta Perl es más en el verdadero espíritu de las reglas (+1).

Sin embargo, tomando una hoja de mniiprespuesta, mi solución podría escribirse así:

print q xHellox and print chr 44 and print q x Worldx and say chr 33

y aunque es más duro para la vista, funciona.

Perl

print chr hex for qw z48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21z

Pitón:

import antigravity 

causa "¡Hola, mundo!" para aparecer en su pantalla. No me creas ¡Pruébelo usted mismo! Además, esto en realidad no usa la web, abre un navegador, que podría buscar un sitio web.

dc, (26 bytes para los golfistas)

[]Ahora se permiten espacios en blanco y corchetes:

[Hello]n44P[ World]n33P[]p

Salida:

$ dc <<< "[Hello]n44P[ World]n33P[]p"
Hello, World!
$ 

Rebmu , 46 caracteres

pnUPPqHELLO01pnADsp12pnSPpnUPPqWORLD01pnADsp01

Paralelamente a la solución de @ dragetun en Rebol (porque Rebmu es una herramienta de enseñanza Rebol / Red que es un "dialecto" que tiene como objetivo llamar la atención sobre los idiomas al mecerse en Code Golf. :-P)

Sin embargo, para obtener los personajes faltantes, hice algo más obvio. Acabo de agregar espacio, en lugar de ir y mirar a través de las cadenas del sistema. Puede agregar espacio 1 para obtener el carácter literal # "!" y agrega espacio 12 para obtener el carácter literal # ",".

Si ejecutamos esto, podemos ver que se "deshace":

>> rebmu/debug/stats "pnUPPqHELLO01pnADsp12pnSPpnUPPqWORLD01prADsp01"
Original Rebmu string was: 46 characters.
Rebmu as mushed Rebol block molds to: 46 characters.
Unmushed Rebmu molds to: 62 characters.
Executing: [pn upp q hello 1 pn ad sp 12 pn sp pn upp q world 1 pr ad sp 1]
Hello, World!

Lo cual es bastante lógico:

; print with no newline the result of doing an uppercase/part
; on the quoting of the symbolic word hello, of only the first
; N characters (where N is 1)
pn upp q hello 1

; print the character you get when you add 12 to the space
; character literal, a.k.a. comma...again no newline
pn ad sp 12

; print a space, no newline
pn sp

; do the same trick of printing the quoted word hello with the
; first letter converted to uppercase
pn upp q world 1

; print the character you get when you add 1 to the space
; character literal, a.k.a. exclamation point...with newline now
pr ad sp 1

Espacio en blanco

De acuerdo, podemos usar espacios en blanco. Sólo se utiliza Space, Tab, LineFeede ignora cualquier otro carácter.

Con comentario: S, To Lmedios Space, Tabo LineFeedrespectivamente.

S S S T S S T   S S S L
T   L
S S S S S T T   S S T   S T L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S T T   T   T   L
T   L
S S S S S T S T T   S S L
T   L
S S S S S T S S S S S L
T   L
S S S S S T T   T   S T T   T   L
T   L
S S S S S T T   S T T   T   T   L
T   L
S S S S S T T   T   S S T   S L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S S T   S S L
T   L
S S S S S T S S S S T   L
T   L
S S L
L
L

Con resaltado: http://en.wikipedia.org/wiki/Whitespace_(programming_language)#Sample_code

T-SQL, 52

Ah, esto es mejor! Conversión binaria directa, solo 52 caracteres.

SELECT CAST(0x48656C6C6F2C20576F726C6421 AS VARCHAR)

Previamente...

Hay una solución mucho más inteligente y golfista que funcionaría si pudiéramos usar =y+ (Buscar datos integrados estándar en msdb y usar eso para construir una cadena de consulta compatible con EXEC)

Pero como no podemos, obtienes este enfoque ingenuo:

SELECT CHAR(72)SELECT CHAR(101)SELECT CHAR(108)SELECT CHAR(108)SELECT CHAR(111)SELECT CHAR(44)SELECT CHAR(32)SELECT CHAR(87)SELECT CHAR(111)SELECT CHAR(114)SELECT CHAR(108)SELECT CHAR(100)SELECT CHAR(33)

Pitón:

Pfff, ¿quién necesita la parte numérica de alfanumérico?

from string import lowercase
from string import uppercase
from string import punctuation
print uppercase[len(str([[[len(str())]]]))]
print lowercase[len(str([[]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([[[[[[[]]]]]]]))]
print punctuation[len(str([[[[[len(str())]]]]]))]
print
print uppercase[len(str([[[[[[[[[[[]]]]]]]]]]]))]
print lowercase[len(str([[[[[[[]]]]]]]))]
print lowercase[len(str([[[[[[[[len(str())]]]]]]]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([len(str())]))]
print punctuation[len(str())]

Esto depende de la configuración regional, por lo que su kilometraje puede variar. Sin embargo, si realmente desea replicar este resultado, puede usar lo siguiente en lugar de las declaraciones de importación:

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

(esto no es parte de mi presentación, solo está compartiendo mis locales para la recreación)

J - 73 char

Se puede hacer, después de todo!

72 101 108 108 111 44 32 87 111 114 108 100 33{do 1 8{show 0 def 0
take
)

Esto es lo que pasa con J. La mayoría de las primitivas son signos de puntuación ASCII, seguidos de hasta dos puntos o dos puntos. Esas primitivas que no están hechas de puntuación son caracteres alfanuméricos seguidos hasta dos puntos o dos puntos. Así que no se nos permite ninguno de esos, excepto { } [ ]. [y ]son verbos de identidad y, por lo tanto, son inútiles.

Afortunadamente, {indexa las matrices, por lo que si tuviéramos, por ejemplo, una cadena con cada carácter ASCII ( a.llamado Alfabeto ), podríamos extraer las letras por sus puntos de código ASCII. También tenemos una forma de respaldo de hacer cadenas , 0 : 0y luego cosas y luego solo ); el colon en el que tiene un alias en la biblioteca estándar,def .

Luego hay un verbo en la biblioteca estándar show, que le da la representación interna de un verbo si le pasa el nombre como una cadena. Hay otro verbo, doque evaluará una cadena. Entonces, si podemos extraer un a.de cualquier representación, podemos evaluar eso y extraerlo Hello, World!.

Nuestro salvador viene en forma de take, un alias para {.que tiene un aen su nombre. show'take'volverá take=: {., entonces tenemos nuestra a.y por lo tanto una solución.

Podemos deshacernos de él {usando el equivalente esencialmente pickde la biblioteca estándar, pero no se puede evitar el par al final.