No idioma de sua escolha, escreva um programa que produz exatamente os caracteres Hello world!seguidos por uma nova linha. O código:

• não deve usar nenhum caractere mais do que duas vezes (alfanumérico, símbolo, espaço em branco ... qualquer coisa)
• não deve usar nenhum recurso externo
• não deve usar nenhuma entrada do usuário
• não deve produzir mais nada

Um exemplo de um programa python válido:

print("He%so world!"%(2*'l'))

Um exemplo de um programa python inválido (o caractere 'r' é usado três vezes):

print("Hel"+chr(108)+'o world!')

O vencedor é quem tiver mais votos após 14 dias.

EDIT: Um vencedor foi escolhido! Obrigado a todos por seu trabalho nesta questão!

Ruby (1.9+)

Como este é um concurso de popularidade, vamos tentar não usar QUALQUER dos personagens de 'Hello world!' enquanto ainda estiver usando outros caracteres apenas no máximo duas vezes:

puts("S\107VsbG8gV29ybGQhCg".unpack(?m))

São 40 caracteres btw.

Bater

E este usa magia unicode.

Notas:

• Enquanto os caracteres originais aparecem em outro lugar (diferente do exemplo do ruby), a sequência impressa contém apenas caracteres não-ascii.
• Dois dos três espaços são realmente guias, portanto, não existem caracteres utf-8 que aparecem mais de duas vezes
• Como alguns dos octetos binários aparecem mais de duas vezes, espero que isso não seja contra as regras. Estou tentando resolvê-los embora.

Código:

echo '𝓗𝐞𝑙𝒍𝓸 𝓦𝗈𝖗𝖑𝘥¡'|iconv -t  asCIi//TRANSLIT

Para aqueles que não têm uma fonte adequada instalada, fica assim:

Aqui está o hexdump:

00000000  65 63 68 6f 20 27 f0 9d  93 97 f0 9d 90 9e f0 9d  |echo '..........|
00000010  91 99 f0 9d 92 8d f0 9d  93 b8 e2 80 8a f0 9d 93  |................|
00000020  a6 f0 9d 97 88 f0 9d 96  97 f0 9d 96 91 f0 9d 98  |................|
00000030  a5 c2 a1 27 7c 69 63 6f  6e 76 09 2d 74 09 61 73  |...'|iconv.-t.as|
00000040  43 49 69 2f 2f 54 52 41  4e 53 4c 49 54 0a        |CIi//TRANSLIT.|
0000004e

Você deve executá-lo em uma máquina onde o conjunto de caracteres padrão é utf-8. Eu tentei em um OSX10.8 usando o iTerm2 com o seguinte ambiente:

PHP 5.4

Isso usa zLib: (infelizmente usa os caracteres ee o)

<?=gzuncompress('x▒▒H▒▒▒W(▒/▒IQ▒!qh');

Hexdump:

00000000  3c 3f 3d 67 7a 75 6e 63  6f 6d 70 72 65 73 73 28  |<?=gzuncompress(|
00000010  27 78 9c f3 48 cd c9 c9  57 28 cf 2f ca 49 51 e4  |'x..H...W(./.IQ.|
00000020  02 00 21 71 04 68 27 29  3b                       |..!q.h');|
00000029

+1

Aqui está o código do ruby ​​2.0 que usei para testar duplicatas:

d=ARGF.read
p [d.split(//),d.unpack('C*')].map{|x|x.inject(Hash.new(0)){|i,s|i[s]+=1;i}.select{|k,v|v>2}}

Você precisa usar idiomas mais expressivos.

Chinês,  6 4   3 caracteres

喂世!

A execução do google translate sobre isso produz Hello world!

(obrigado @reservoir e @Quincunx pela atualização)

HQ9 +, 1 caracter

H

mantendo-o simples :)

C, 192 caracteres

#
#
/*$$@``*/ATION_[]={9.};main(BBCDDEEFFGGHJJKKLLMMPPQQRRSSUUVVWWXXYYZZabbdefgghhjjkkmpqqsstuuvvwxyyzz) {printf("He%clo \
world!%c\
",2^7&!8.&~1|~-1?4|5?0x6C:48:6<3>2>=3<++ATION_[0],'@'^79-5);}

Como isso não é golfe, decidi me divertir e tentar usar todos os personagens exatamente duas vezes (colocando o mínimo possível em um comentário, porque isso é chato). Percebo que não me saí muito bem, já que meu código também contém uma tonelada de códigos "mortos" entediantes (não no sentido literal, mas no sentido de caracteres de espaço reservado usados ​​apenas para atender ao requisito). Enfim, isso foi surpreendentemente difícil (mas divertido) com a limitação de dois caracteres, então, infelizmente, eu não consegui pensar em algo mais interessante. Isso me deu uma idéia para um novo problema ...

(Atualizado de acordo com o comentário de @ ugoren.)

Comando Vim (18 teclas)

iHeEsc3alEscio WorRightd!Enter

Não repete o pressionamento de tecla mais de duas vezes.

Ele meio que viola a regra "user input", pois ainda é o usuário que precisa inserir essa sequência, mas suponho que se você armazená-lo como uma macro ou um nnoremap de antemão, isso contaria, já que você o está executando sem fazer explicitamente entrada para que isso aconteça.

Também precisa nocompatibleser definido, o que pode contar como o uso de recursos externos, por isso forneci outra variação abaixo:

Comando Vim (21 teclas)

iHeEsc3alEscio WorCtrl+[$ad!Enter

Essa variação não precisa nocompatibleser definida, embora funcione usando Esctrês vezes usando Ctrl+[em seu lugar.

Piet-- Nenhum personagem!

Perl, 29 caracteres

Esta resposta inclui tamancos com classificação x!

say"07-8*d<#B+>!"^xRATEDkL0GZ

Perl, 23 caracteres

Mais curtos, mas sem sapatos porno. :-( A mesma idéia básica ...

say'0@@lo World!'^"x%,"

Perl, 20 caracteres

Entediante...

say"Hello Wor\x6Cd!"

Powershell, 20

"He$('l'*2)o world!"

Sclipting , 11 caracteres

丟낆녬닆묬긅덯댦롤긐뤊

Eu vi esse lindo programa HelloWorld na lista de programas Hello World da esolang .

Scala: 34 29 caracteres

Estou orgulhoso de mim mesmo por este:

printf("He%c%co world!\n",108,108)

Tivemos muita dificuldade em superar 'l', 'r', aspas e colchetes. Então descobri a antiga printffunção Java , que felizmente converte números em letras quando é fornecido o %cespecificador de formato.

Atualizar

MrWonderful fez uma coisa maravilhosa, apontando que vários caracteres podem ser salvos usando meu segundo 'l' manualmente na string!

printf("Hel%co world!\n",108)

Python 3 [38 bytes]

exec('import '+chr(95)*2+"h\x65llo__")

Eu não consideraria import __hello__um recurso externo.

Perl: 34 caracteres

$_="He12o wor3d!
";s{\d}{l}g;print

Exemplo de execução:

bash-4.1# perl -e '$_="He12o wor3d!
> ";s{\d}{l}g;print'
Hello world!

(Não é grande coisa. Postado apenas para usar pelo menos uma vez na minha vida s///com esses delimitadores sofisticados.)

PHP, 33 caracteres

Eu simplesmente amo o quanto o PHP perdoa e entende!

<?=Hel.str_rot13("yb jbe").'ld!';

Antes de ser excluído (ou, se ainda estiver lá, estou totalmente cego), vi um comentário dizendo "No brainf * ck?: D". Bem, é praticamente impossível escrever uma solução no BrainF * ck, como você sabe. Mas eu consegui codificar isso, apenas para o lulz.

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

Se você não possui um intérprete de BF, o código acima apenas imprime o do PHP: P

Violino HTML - 21 caracteres

Hel&#108;o World!<br>

Ruby: 27 caracteres

puts [:Hel,'o wor',"d!"]*?l

Exemplo de execução:

bash-4.1# ruby <<ENDOFSCRIPT
> puts [:Hel,'o wor',"d!"]*?l
> ENDOFSCRIPT
Hello world!

Ruby: 25 caracteres

(Baseado no comentário de Vache.)

puts 'He'+?l*2+"o world!"

Ruby: 23 caracteres

(Cópia da resposta do PowerShell de Danko Durbić .)

puts"He#{?l*2}o world!"

JavaScript, 66 caracteres

alert('Hel'+window.atob("\x62G8gd29ybGQhCg=="));//rH+in.\x689yQhC;

Inspirado no FireFly, todos os caracteres usados ​​por esse código são usados ​​exatamente duas vezes.

C - 43 caracteres

main(){printf("Hel%co World!%c",'k'+1,10);}

Resultado

Hello World!

Contagem de caracteres

' ' Count: 1    '!' Count: 1    '"' Count: 2    '%' Count: 2    ''' Count: 2
'(' Count: 2    ')' Count: 2    '+' Count: 1    ',' Count: 2    '0' Count: 1
'1' Count: 2    ';' Count: 1    'H' Count: 1    'W' Count: 1    'a' Count: 1
'c' Count: 2    'd' Count: 1    'e' Count: 1    'f' Count: 1    'i' Count: 2
'k' Count: 1    'l' Count: 2    'm' Count: 1    'n' Count: 2    'o' Count: 2
'p' Count: 1    'r' Count: 2    't' Count: 1    '{' Count: 1    '}' Count: 1

JavaScript [37 bytes]

alert(atob("SGVsbG8g")+'wor\x6cd!\n')

Muito primitivo, não é?

nginx.conf

return  200 "He&#x6clo wo&#x72ld!\n";

Em ação:

% curl -6 http://localhost/ | lynx -dump -stdin
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100    21  100    21    0     0  20958      0 --:--:-- --:--:-- --:--:-- 21000

   Hello world!

%

Comando Emacs (15 pressionamentos de teclas)

He<Ctrl-3>l<Left>o wor<End>d!<Enter>

Se essa resposta do vim for legal, isso também deve ser :)

Brincadeiras à parte, macro pode se tornar muito :)

Mais bobagens à parte, provavelmente posso espremer um pouco mais, mas isso parece ser bom o suficiente por enquanto (já que ele supera o vim).

PS, por favor, ignore todas as minhas bobagens (eu (raramente, mas) uso o vim também!).

Befunge 98

a"!dlrow ol":'e'Hck,@

Aqui está uma versão em que cada personagem aparece duas vezes.

bka!e:dw"H@!dlrow  ol":'e'Hbk,a,@

Deixa um monte de lixo na pilha.

Como bônus, todo personagem tem algo a fazer com o IP.

Malbolge

(=<`#9]~6ZY32Vw/.R,+Op(L,+k#Gh&}Cdz@aw=;zyKw%ut4Uqp0/mlejihtfrHcbaC2^W\>Z,XW)UTSL53\HGFjW

Na verdade, eu não gosto de trapacear: P

Pitão

print("!dlrow os%eH"[::-1]%('l'*2))

GolfScript

'He

o world!'n/"l"*

Substitui duas novas linhas (felizmente a terceira, necessária para a substituição, é fornecida pelo interno n), usando os dois tipos de literal de cadeia para evitar cópias quadruplicadas de aspas. Como lé o único caractere que ocorre mais de duas vezes na string original, não é muito difícil.

Hmm.

Em C, dadas essas regras, só podemos ter uma #define(por causa de ie n) e no máximo duas chamadas de função OU definições ( (e )).

Presumo que exista apenas uma maneira de fazer isso (embora eu provavelmente esteja errado):

main(){puts("Hello w\x6fr\154d!");}

BATER

printf 'Hel\x6co world!\n'

Cred @manatwork

echo $'Hel\x6c\x6f world!'

C - 46 caracteres

main(){printf("He%clo wor%cd!\x0d",'l',108);}

Imprime:

Olá Mundo!

Fuga

No wiki da esolang:

E você pode ouvir o código fonte .

PHP

32 Chars

Observe como não estou usando um caractere mais do que duas vezes, pois l! = L

He<?=strtolower("LLO WOR");?>ld!

Observe também que, apesar do Stack Overflow excluí-lo na representação, há uma quebra de linha após o !.

XQuery, 19 caracteres

"Hello World!"