Seu objetivo é escrever "Olá, mundo!" (menos as aspas). Este é um concurso de popularidade , e a maioria dos votos ganha. O comprimento do código será usado para romper laços.
Tudo vale, desde que esteja dentro das seguintes regras:

• Todos os caracteres devem ser letras ou números, portanto, você pode usar apenas caracteres na cadeia "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".
• Todo o código que você usa deve estar em um arquivo, com exceção dos módulos / classes importados / como eles são chamados no seu idioma favorito.
• Somente as bibliotecas / estruturas padrão para o seu idioma de escolha são permitidas (por exemplo, o módulo Math do Python é permitido, mas Numpy, Scipy e Pygame não são). Permitirei o TkInter, pois é o padrão de fato para GUIs em Python.
• Nenhuma entrada é permitida, seja lendo a partir de stdin, lendo um arquivo, exibindo uma imagem ou lendo na web.

+10 pontos de brownie se você descobrir como fazê-lo em Java sem violar as regras.

Em suas marcas, prepare-se, código!

EDIT: chaves ({}), colchetes ([]) e parênteses (()) são permitidos, pois isso seria praticamente impossível para a maioria dos idiomas sem eles. Também estou removendo a regra de limite de caracteres. Espero que isso torne mais interessante.

EDIT ^ 2: espaço em branco também é permitido. Meu cérebro não está funcionando corretamente, desculpe. >. <

Perl

Alguns dizem que perl é uma linguagem cheia de ruído ascii e símbolos aleatórios como $... Isso não é verdade: P

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

Vamos dividir isso em subexpressões:

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

Deveria ser óbvio que ele é executado da esquerda para a direita, desde que toda expressão retorne verdadeira. Mas o que diabos é isso s zqzchr 44ze?

Em Perl, há um grupo de "quote-like operadores" que inclui q(str), qw(li st), /regex/, s/from/to/entre outras coisas. Acontece que todos esses operadores podem usar quase qualquer caractere como delimitador, com algumas particularidades: a parênteses de abertura deve ser fechada por um parêntese de fechamento correspondente e, se você deseja usar uma letra como delimitador , deve colocar um espaço após a letra do operador (para desambiguá-la de uma palavra de barra).

Nesse caso, vemos três usos do s///operador (substituição de expressão regular):

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

Tudo delimitado pelo personagem z. O /esinalizador nos dois últimos faz com que a substituição seja interpretada como código a ser avaliado, em vez de texto literal.

Um fato bastante conhecido sobre perl é que a maioria das operações padroniza a operação na $_variável embutida, a menos que especificado de outra forma. Todas essas três substituições e printoperam $_nesse caso. Primeiro, colocamos as palavras Hello world na variável, depois fixamos a pontuação usando os valores numéricos ascii dos caracteres, depois imprimimos o conteúdo da variável.

C

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 básico mudou-se para separar a resposta conforme sugerido. A maioria dos votos sobre isso é definitivamente para a resposta do LOGO.)

LOGOTIPO

Intérprete em 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

Saída (o triângulo verde é o cursor da tartaruga)

Applescript

Não há colchetes [], {}parênteses ou parênteses ()neste:

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

A saída é:

Bater

Esse tipo de funciona, se você apertar os olhos:

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

Satisfaz as regras originais.

Pitão

Então, assumimos que todo mundo lê horizontalmente? Para os usuários que gostam de ler 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)

Poliglota: HQ9 +, H9 +, HQ9 ++, CHIQRSX9 +, HQ9 + B e HQ9 + 2D (1 byte)

H

Obrigado @victor pela lista de idiomas.

OMGROFL

Sou um grande fã de línguas esotéricas. Felizmente, o OMGROFL é 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

O izcomando define um valor para uma variável, neste caso lol, loole looolserve como variáveis ​​...

O roflcomando ecoa o equivalente ASCII ao número armazenado na variável.

O stfucomando finaliza o 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 

Foram necessárias algumas alterações para se tornar apenas uma fonte verdadeiramente alfanumérica.

A ID do PROGRAMA pode ser descartada. Você obtém um nome de programa gerado (consulte as mensagens).

O ARMAZENAMENTO DE TRABALHO pode ser descartado. Novamente o compilador geme.

Como essas duas linhas anteriormente tinham pontos / pontos ausentes ausentes, que não são mais relevantes agora que as descrições estão ausentes, o número de mensagens de erro é o mesmo de antes e ainda não afeta o código gerado para o programa.

Ao alterar o COMP-5 para COMP, as cláusulas VALUE não são mais permitidas, pois o COMP 9999 possui apenas quatro dígitos decimais, enquanto o COMP-5 é um binário de dois bytes com todos os valores de bits disponíveis.

Os valores nos MOVEs são os valores decimais que fornecem os valores binários que fornecem os pares de caracteres.

Mesmo que os campos COMP tenham quatro dígitos e não permitam cláusulas VALUE com mais de quatro dígitos, você pode usar mais dígitos no MOVE de um valor literal sem truncamento nesse ponto ... não me pergunte por que. A opção do compilador DIAGTRUNC (que eu desliguei) produzirá diagnósticos de aviso para eles.

A opção do compilador TRUNC (BIN) pode ser usada para tratar o COMP como COMP-5, mas os MOVEs são outra maneira de fazê-lo.

Por ser COBOL, a saída deve estar em MAIÚSCULAS (uma mentira, mas apenas por diversão).

HELLO WORLD!

OK, cedido, agora produz:

Hello, World!

O qual, sendo um número ímpar de caracteres, exigiu algumas alterações adicionais, já que não podemos ter campos binários de números ímpares com este compilador. Olhe para essa linha de 13 Xs! Normalmente seria escrito como X (13), mas pode ser como eu mostrei ...

E ORTEXT é necessário (ou não OR, de qualquer maneira) como um nome, porque OR é uma palavra reservada para o compilador (significa OR, é claro).

Esses são os valores EBCDIC, não ASCII, pois estão sendo executados em uma caixa compatível com EBCDIC e Big Endian.

Oh, COBOL requer muitos pontos / períodos completos. Eu os deixei de fora (eles são banidos), então recebi muitas mensagens de compilação. Apenas disse ao compilador para gerar o código de qualquer maneira (nenhuma das mensagens está relacionada ao código do objeto).

Mesmo sem DIAGTRUNC, as mensagens agora têm até 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 apenas alnums e espaços em branco)

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

Resultado: Hello, World!

Javascript

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

Use o console do navegador para testar.

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

Única solução alfanumérica:

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

Acima está uma atualização que usa a excelente sugestão do Dr. Rebmu de add space 1(que produz !) para chegar a todos os personagens.

Abaixo está a versão original:

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

Versão mais curta com suportes:

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

E versão ainda mais curta com aparelho:

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

E versão mais curta com suportes e chaves:

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

A Rebol usa chaves {}para cotação de várias linhas. Tão completamente válido sob mudanças de regras, mas não com todo o espírito (IMHO), como minhas duas primeiras respostas acima.

NB Imprimir o !foi uma dor!

O Rebol permite e usa caracteres de pontuação rotineiramente para nomes de funções e tipos de dados. Portanto, opções como to-char 33ou to char! 33não seriam permitidas sob as regras (mesmo que essas pontuações não sejam operadores par se).

Felizmente, encontrei uma maneira atrevida, transformando o objeto do sistema Rebol: make object! [...]em uma corda e em uma cereja, escolha !isso :)

Atualização: E agora também a vírgula escolhida pela cereja no texto da licença no objeto do sistema.

C

Usa apenas caracteres alfanuméricos, espaços e chaves {}, colchetes [] e parênteses ().

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

printf () aceita um char * como argumento, mas como não podemos usar aspas ("), eu tipecast a string como uma matriz longa e longa. Os valores vistos aqui são strings ASCII, em little endian (0x48 = H, 0x65 = e, 0x6c = l e assim por diante.] Eu o estimei por muito tempo [], pois dessa forma posso passar um argumento de 8 bytes e, portanto, usar apenas duas chamadas printf () em vez de quatro.

BBC BASIC

Emulador em bbcbasic.co.uk

Separado da minha resposta do LOGO.

O caminho fácil

Os números à direita são apenas códigos ASCII. É exatamente o mesmo que imprimir. Se me permitisse uma vírgula, poderia fazê-lo em uma única linha ( 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

Uma maneira mais criativa

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

DC

O DC é a ferramenta perfeita para o trabalho.

5735816763073854918203775149089P

O Pcomando DCs exibe um número da pilha e envia sua representação bruta do computador para o STDIO. Vendo como 5735816763073854918203775149089 = 0x48656C6C6F2C20576F726C6421, que é representado como 0x21, 0x64, 0x6C... = 'H', 'e', 'l'...em uma arquitetura little-endian, ele gera Hello, World!.

JavaScript!

E eles disseram que isso não poderia ser feito ... Sem operadores de atribuição, sem concatenadores, sem aspas! Arghhhh!

Não temas ... Pois a força é withvocê ...

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

Atualização: Conseguiu cortar um monte de personagens introduzindo também uma função Mundial.

Outra solução Javascript que grava no 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 .

Primeiro, defino funções nomeadas Olá e Mundo. Isso será usado mais tarde.

Então inicio minha cadeia de aninhados. O with (console)e with (String)são usados ​​para que eu possa chamar mais tarde console.loge String.fromCharCodesem usar um ponto.

O plano agora é construir a string Hello, World!abusando de aninhadas. Cada vez que chamei concat (), a string resultante será o contexto no próximo with-block. Tomo um atalho para "Hello"acessar rapidamente a namepropriedade da Hellofunção. Então concatenar os caracteres de vírgula e espaço usando String.fromCharCode.

O próximo truque é obter a "World"parte da string. Não posso usar o mesmo método que costumava obter Hello, pois não posso invocar World.name. Em vez disso, coloquei essa lógica dentro do método World e a invoco.

Por fim, anexo o ponto de exclamação final e envio o resultado diretamente para a função de log, que é obviamente console.log.

Perl

Em um Perl moderno (5.10 ou mais recente):

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

No Perl mais antigo:

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

Ambas as soluções acima usam o qoperador de aspas do Perl e permitem delimitadores seletivos para citar uma string, por exemplo. q{} q[] q() q//

Esta solução requer a alteração de regra que permite chaves, parênteses ou parênteses. Portanto, apesar de totalmente válido, acho que uma mniipexcelente resposta Perl está mais no verdadeiro espírito das regras (+1).

No entanto, tirando uma folha da mniipresposta, minha solução poderia ser escrita assim:

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

e, embora seja mais difícil, funciona.

Perl

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

Pitão:

import antigravity 

causa "Olá, mundo!" para aparecer na sua tela. Não acredita em mim? Experimente você mesmo! Além disso, na verdade, isso não usa a web, abre um navegador que pode procurar um site.

dc, (26 bytes para os jogadores)

Espaço em branco e []colchetes agora são permitidos:

[Hello]n44P[ World]n33P[]p

Resultado:

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

Rebmu , 46 caracteres

pnUPPqHELLO01pnADsp12pnSPpnUPPqWORLD01pnADsp01

É paralelo à solução da @ dragetun no Rebol (como o Rebmu é uma ferramenta de ensino Rebol / Red que é um "dialeto" que visa chamar a atenção para os idiomas, agitando no Code Golf. :-P)

No entanto, para obter os personagens ausentes, fiz algo mais óbvio. Acabei de adicionar espaço, em vez de procurar e analisar as strings do sistema. Você pode adicionar espaço 1 para obter o caractere literal # "!" e adicione espaço 12 para obter o caractere literal "", ".

Se rodarmos isso, podemos ver "silencioso":

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

Qual é razoavelmente logial:

; 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

Espaço em branco

Ok, podemos usar espaço em branco. Ele usa apenas Space, Tab, LineFeede ignora quaisquer outros caracteres.

Com comentário: S, Tou Lmeios Space, Tabou 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

Com destaque: http://en.wikipedia.org/wiki/Whitespace_(programming_language)#Sample_code

T-SQL, 52

Ah, isso é melhor! Conversão binária direta, apenas 52 caracteres.

SELECT CAST(0x48656C6C6F2C20576F726C6421 AS VARCHAR)

Anteriormente...

Existe uma solução muito mais inteligente e eficiente para isso que funcionaria se pudéssemos usar =e +( Consultar dados internos padrão no msdb e usá-lo para construir uma cadeia de consulta compatível com EXEC)

Mas como não podemos, você recebe essa abordagem ingênua:

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ão:

Pfff, quem precisa da parte numérica do 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())]

Isso depende da localidade, portanto, sua milhagem pode variar. No entanto, se você realmente deseja replicar esse resultado, poderá usar o seguinte em vez das instruções de importação:

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

(isso não faz parte do meu envio, é apenas compartilhar meus locais para recreação)

J - 73 char

Isso pode ser feito, afinal!

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

Aqui está a questão sobre J. A maioria das primitivas é pontuação ASCII, seguida por até dois pontos ou dois pontos. As primitivas que não são feitas de pontuação são um caractere alfanumérico seguido de dois pontos ou dois pontos. Portanto, não é permitido nenhum deles, exceto { } [ ]. [e ]são verbos de identidade e, portanto, são inúteis.

Felizmente, {indexa matrizes, portanto, se tivéssemos, digamos, uma string com cada caractere ASCII ( a.chamado alfabeto ), poderíamos extrair as letras pelos seus pontos de código ASCII. Também temos uma maneira alternativa de criar strings , 0 : 0e depois outras coisas ); o cólon no qual tem um alias na biblioteca padrão def,.

Depois, há um verbo na biblioteca padrão show, que fornece a representação interna de um verbo se você passar o nome como uma string. Há outro verbo do, que avaliará uma string. Portanto, se pudermos retirar um a.de qualquer representação, podemos avaliar isso e retirar Hello, World!.

Nosso salvador vem na forma de take, um apelido para {.isso tem um aem seu nome. show'take'retornará take=: {., então temos a nossa a.e, portanto, uma solução.

Podemos nos livrar {usando o equivalente essencialmente pickda biblioteca padrão, mas o ponto final não pode ser evitado.