Escreva um programa que não aceite entrada e imprima Hello, World!no stdout ou na alternativa mais próxima do seu idioma. O problema é que cada linha do seu programa deve conter apenas caracteres ASCII imprimíveis e deve estar em ordem lexicográfica, também conhecida como classificada.

Aqui estão todos os 95 caracteres imprimíveis ASCII em ordem:

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

Portanto, por exemplo, a linha !!A0~seria inválida porque Ae 0está fora de ordem. A linha !!0A~seria válida.

Cada linha do seu programa pode ter qualquer comprimento e pode haver qualquer número de linhas. Linhas vazias são consideradas classificadas. Cada uma das novas linhas do seu programa deve ser a mesma (sem mistura \ne \r\n). Guias e outros caracteres ASCII não imprimíveis são proibidos.

Devido à demanda popular , a condição de vitória foi alterada:
a finalização com o menor número de linhas vence. O desempatador vai para o programa mais curto (as novas linhas contam como caracteres únicos).

Somente Hello, World!uma nova linha à direita opcional deve ser impressa. Observe que o HQ9 + é inválido, pois é geradohello, world . Posso proibir idiomas semelhantes ao HQ9 + que tenham um caractere "Olá, mundo!" comandos devido à sua trivialidade.

Dica:

Definitivamente, isso é possível em Unary e Lenguage , embora não seja muito conciso.

Headsecks , 1 linha, 366 bytes

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

Headsecks é uma substituição trivial do Brainfuck, onde a única coisa que importa é o módulo de ponto de código 8. O Brainfuck equivalente é apenas

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

Felizmente essa abordagem ingênua apenas se encaixa. Existe algum potencial para obter bytes de golfe, mas pode ser difícil.

Testado usando este intérprete Python .

Gerando 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 linhas, 22 bytes

/
//Hello
,
 Wor
l
d
!

Uma rara chance de /// ser competitivo (desde que ninguém comece com Unary e Lenguage ...).

O código encontra primeiro um /e analisa o

/
//

como uma instrução de substituição que remove todas as novas linhas do restante do programa. Posteriormente, o programa apenas lê

Hello, World!

que é impresso literalmente, pois não contém mais barras.

JavaScript (67 66. 62 linhas, 227 269 ​​bytes)

(Nota: testado apenas no Firefox 36 e Safari 8, contém recursos menores do ES6 (a Setclasse))

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]
+
"\
!')\
")
()

O código acima basicamente:

alert("Hello, World!")

Obviamente alertnão está classificado. Então, em vez disso, precisamos gerar a instrução como uma string e "eval":

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

Como gerar a string? O ES5 suporta a continuação da linha para que

"AL\
ERT" === "ALERT"

Mas o código do caractere \aparece antes de todas as letras minúsculas, portanto, precisamos gerar as letras minúsculas usando outros métodos.

Nós emprestamos alguma idéia do JSFuck aqui. As letras minúsculas envolvidas nas instruções de alerta são:

t e r a o l d

tudo isso pode ser extraído de caracteres de objetos padrão, que podem ser expressos em termos de alguma sequência classificada:

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

Como avaliamos a string? Certamente não podemos usar, eval(s)pois não está classificado. Como alternativa, poderíamos usar Function(s)(), mas não podemos usá- Functionlo, pois também não é classificado. No entanto, Functioné o construtor de todas as funções, o que significa Set.constructor === Function.

Adicionar o identificador constructorfaz com que a lista de letras minúsculas se torne:

t e r a o l d c u n s

que felizmente ainda poderia ser gerado por "truefalseundefinedfunction":

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

Após a pré-justificação, o código acima deve ter a seguinte redação:

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

Update: Renomeado E, L, O, R, Ta vários repetição de $reduzir 4 linhas.

Insônia , 4 linhas, 59 bytes

 FFFFGjnnnnooty
FLLddeejkopqyyyyy~~
(<ddjnoppppqrtu
<<Fddfj

Este programa é gerado otimizando a contagem de linhas.

10 linhas, 43 bytes

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

O programa acima é gerado otimizando a contagem de bytes.

Cygwin bash, 16 linhas, 60 bytes

Isso funciona apenas devido ao nome do arquivo que não diferencia maiúsculas de minúsculas no Windows e pelo fato de o Cygwin procurar os utilitários sem diferenciação de maiúsculas e minúsculas, mesmo que você não o configure para reconhecer o caminho sem maiúsculas e minúsculas.

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

Tome nota disso ECHOno final.

> <> , 6 linhas, 111 bytes

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

Estou tendo problemas para jogar fora uma linha extra, mas, de qualquer forma, estou feliz por ter vencido o método das 7 linhas.

Explicação

> <> é uma linguagem 2D baseada em pilha em que as instruções são caracteres simples e o fluxo do programa pode ser ativado, desativado, esquerdo ou direito. A "instrução alterna a análise de strings, pressionando chars até que um fechamento "seja alcançado, mas devido à natureza de> <> não existe "análise de strings com várias linhas", como as strings de CJam ou as triplas citadas no Python. Isso acabou sendo um grande problema, porque iniciar e terminar uma linha com a "e ter outros caracteres no meio (por exemplo "some chars") não é permitido!

Observe que /e \refletimos o fluxo do programa, portanto, na verdade, executamos a primeira linha e todas as linhas na ordem inversa, e a maioria das linhas é realmente executada ao contrário!

[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

Em uma nota lateral, aqui está uma tentativa divertida de> <> menos bytes (23 linhas, 47 bytes):

v
"
!
d
l
r
o
W

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

CJam, 5 4 linhas, 162 bytes

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

Mesmo número de linhas que Insomnia! (mas muito mais bytes)

Experimente online .

Explicação

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

O CJam imprime automaticamente a pilha posteriormente.

Agradeço ao @Optimizer por me lembrar que Scfunciona, porque, caso contrário, SX|falha (faz um setwise ou, ao contrário, fornece a matriz que consiste em um espaço e 1).

> <> (Peixe) , 5 linhas, muitos bytes

O código é extremamente longo, quando digo [6535529689086686142930090 '+' signs]e [6535529689086686142930090 'd' characters]na primeira linha do código, quero dizer que existem literalmente 6535529689086686142930090sinais de mais em uma linha!

(E para as seguintes linhas, adicione os espaços de prefixo necessários.)

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

Uma alternativa testável mais curta que apenas imprime Hi:

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

Método:

• Na primeira linha, criamos um grande número representando a string na base128.
• Nas demais linhas (de baixo para cima), imprimimos o seguinte caractere em cada loop até que o valor do número inteiro atinja 0.
• O código de loop é :1(?;:882**%:o-288**,.

(Podemos imprimir uma sequência longa de 2 + caracteres arbitrários com esse método.)

PHP (7/17 linhas, 36/59 bytes):

Devido à quantidade de resposta inválida, reescrevi esta resposta.

A versão do navegador? Se foi.

Mas eu tenho 2 soluções, ambas baseadas em bit a bit xor( ^) de strings em PHP.

Esta é uma solução extremamente poderosa! Às vezes, permite economizar muitos bytes.

Primeiro, a resposta mais curta:

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

Eu sei, parece horrível, mas funciona!

O próximo depende de novas linhas.

Sim, ele usa novas linhas (o \nestilo / UNIX é necessário)!

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

As novas linhas desta são necessárias para funcionar.

Não é perfeito, mas funciona!

Ambas as respostas foram baseados em @ MartinBüttner 's solução :

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

Um agradecimento especial a @ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ , @CJDennis , @ MartinBüttner e @skagedal por detectar todos os meus erros e por suas sugestões.

Pitão, 7 linhas, 23 bytes

-
"Hello
,
 Wor
l
d
!"b

Muito simples, basta usar uma sequência de múltiplas linhas e remover as novas linhas.

Experimente aqui.

Quarto, 41 linhas, 143 bytes

Experimente online.

Eu estou muito orgulhosa disso. Eu o peguei rapidamente, assim que descobri que podia fazê-lo, depois que o Google pesquisou idiomas que não diferenciam maiúsculas de minúsculas e já conheço a Forth decentemente. Definitivamente, pode ser reduzido, bytes e linhas. Sugestões são apreciadas. : D

Esse programa basicamente empurra o valor decimal de cada caractere ASCII e depois imprime cada um. Tentei otimizar enquanto escrevia, portanto é menos legível do que gostaria.

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

Marbelous, 9 linhas, 94 bytes

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

Teste online aqui. Using spaces for blank cellsdeve ser verificado.

Representação visual da fonte:

Explicação: Cada valor hexadecimal neste programa se move para baixo a cada "tick" (a menos que esteja ativado \\, caso em que se move para a direita). ++aumentará o valor, --diminuirá, não ~~aplicará um bit a bit, etc. Os valores que caem da parte inferior são impressos como um caractere ASCII.

Por exemplo: O 33no canto superior se torna (((0x33 +1 +1) << 1) +1 +1 = 0x6C (l).

Perl, 17 linhas

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

Rebol - 15 linhas (51 bytes)

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

As palavras em Rebol não diferenciam maiúsculas de minúsculas (por exemplo PRINT, Printe printtodas chamariam a mesma função).

O código acima arrumado:

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

NB spretorna o caractere de espaço !

Unário , 1 linha, muitos bytes

Todos os personagens deste programa são 0. A fonte é muito longa para ser inserida aqui, mas consiste em uma sequência de muitos zeros:

327380789025192647555922325233404088310881092761595127419003295178342329930050528932118548

Esta é a representação decimal para este número binário:

0b1010010010010010010010010110000010010010010110000010010000010010010000010010010000010001001001001011111000010000010000011110001111001011111000000100000011011011100010010010010010010010100100010010010100000000100001011100001100010010010100011011011011011011100011011011011011011011011100000000010100

Que foi criado a partir deste programa BrainF ***:

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

Veja como eu o gerei : http://ideone.com/lMT40p

Lote - 39 linhas (202 bytes)

Eu queria reduzir o tamanho, permitindo a expansão atrasada executando o código dentro de uma cmdchamada usando o /v oncomutador, mas não consegui superar todos os 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^
!^^^
!

Sem as novas linhas (e quilates para escapar das novas linhas):

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

Ruby, 19 linhas, 95 bytes

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

Possivelmente a segunda restrição de código mais difícil para Ruby que eu já vi neste site, depois da monstruosidade aqui .

Editar para explicação: o único método de saída Ruby classificado é o <<método STDOUT. Infelizmente, a constante para STDOUT é $>e> é maior em ASCII do que a maioria dos símbolos; portanto, não é possível chamar um método nele. Precisamos de uma declaração de atribuição de várias linhas para obter um nome de variável mais tratável $;(ponto-e-vírgula ainda é bastante alto, mas a maioria das variáveis ​​desse formulário é não atribuível ou pode ser apenas uma sequência de caracteres).

Símbolos ( :Wor, etc.) são a maneira mais fácil de fazer um literal, e não vejo uma maneira de remover novas linhas de uma string, portanto, preciso de várias instruções de impressão. O espaço e a pontuação não podem ser literalmente simbolizados, mas, felizmente, o chrmétodo dos números é legal, para que eu possa obter um caractere do seu valor ASCII. ::é uma maneira alternativa de chamar métodos. O espaço é complicado porque não consigo escrever 32, portanto, subtraio 1 de 33 e o atribuo a uma variável.

Retina, 12 linhas, 29 bytes (não concorrente)

A linguagem é mais nova que o desafio.

Hello
$
,
$
 Wor
$
l
$
d
$
!

Experimente online