Crie o programa ofuscado mais curto possível que exibe o texto "Hello World".

Para ser considerado um programa ofuscado, ele deve atender a pelo menos dois dos seguintes requisitos:

• Não conter os caracteres: h, l, we dem qualquer caso
• Não conter os caracteres: e, o, r, 0, e 1, em qualquer caso
• Não contém os caracteres: 2ou7

Entrada:
nenhuma

Resultado:
Hello World

GolfScript, 17 caracteres

'· Š ““ ?? ߨ ???? “›' {~}%

Ao testar esse envio, salve o arquivo como binário direto, não como UTF-8. Está tendo problemas para recriar o arquivo? Aqui está o hexdump:

00000000  27 b7 9a 93 93 90 df a8  90 8d 93 9b 27 7b 7e 7d  |'...........'{~}|
00000010  25                                                |%|

Perl

Como a resposta óbvia usa algum tipo de mudança, sinto-me obrigado a postar algo usando o Acme :: EyeDrops , mas com o poder extra que achei que o meu deveria ser um pouco mais divertido.

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

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

                            ';'.('`'|',').
                        ('`'|'!').('['^    '('
                    ).('['^'/').(('{')^        '['
                 ).('`'|')').("\`"|    (          '&'
              )).'\\'.'$'.('`'|"\*").                '='
            .'='.'\\'.'@'.('`'|"\#").                  (((
          '\\'))).'}'.('['^'+').('['^  (                 ')'
         )).('`'|')').('`'|'.').('['^   (                 '/'
       )).'\\'.'"'.'\\'.'\\'.('`'      |+                   '.'
      ).'\\'.'"'.('!'^'+').'"'.'}'.   ')'                    );(
     $:)='.'^'~';$~='@'|'(';$^=')'^                           '['
    ;$/='`'|'.';$,='('^'}';$\="\`"|                            '!'
   ;$:=')'^'}';$~='*'|'`';$^=('+')^                             '_'
   ;($/)    ='&'|'@';$,='['&'~';$\                              =((
  "\,"))^    '|';$:  ='.'^'~'; $~                                =((
  '@'))|     "\(";    $^=')'^                                    '['
 ;($/)=      '`'|       '.';$,                                    =((
 '(')        )^+         '}';$\                                   =((
'`')          )|          "\!";      (           (                 $:)
)=')'         ^+        (   (         (                   (        '}'
))));          (           (          (                            $~)
))=(                    (   (    (        (                        '*'
))))                     )   |  ((      (                          '`'
)))                      ;     $^=         (                       '+'
)^+                       ((    ((  ((     '_'                     )))
)))                                          ;($/)                 =((
'&'                          ) )               |'@';               $,=
'['                                                                &((
 '~'                                      ))   ;                  $\=
 ','                                  ^"\|";  $:                  =((
  '.'                               ))^"\~"; $~=                 '@'
  |((                              '('));$^=')'^       (         '['
   );(                          $/)='`'|"\.";$,=    (           '('
   )^+                         '}';$\='`'|'!';$:                =((
    ')'                        ))^'}';$~='*'|'`'               ;$^
     =((                       '+'))^'_';$/='&'               |((
      '@'                      ));$,   =('[')&               '~'
       ;$\                              =','^               '|'
         ;$:                              =(      ((      '.'
          )))                                   ^+       '~'
            ;$~                               =(       '@'
              )|+                                    '('
                 ;$^                              =((
                    ')'                        ))^
                        '['                ;$/
                            ='`'|('.');#;#

Embargo

Desde a versão 5.18 do Perl, o mecanismo que permite a execução desse código tornou-se tão poderoso que foi desativado por padrão para evitar o uso indevido. Portanto, nas versões 5.18+, você pode adicionar use re 'eval';à parte superior do script ou, se o script tiver o nome, world.plpoderá executá-lo como ele perl -Mre=eval world.pl. É lamentável que esses caracteres desagradáveis ​​sejam adicionados, mas c'est la vie. (Nota: quero enfatizar que ativar esse recurso não está usando alguma biblioteca ou complemento, o código exibido é um código Perl válido, o mecanismo simplesmente não está mais ativado por padrão).

C # (175 caracteres)

Foi um grande desafio fazer isso em C # porque as restrições impedem o uso de muitas das palavras-chave comuns. É possível em C # usar sequências de escape Unicode \ uxxxx nos identificadores, mas infelizmente não nas palavras-chave.

Suspeito que esta solução só funcione quando compilada no .NET 4.0. Veja a explicação para o porquê.

using System;struct a{static int Main(){object[]c={"\u0048e\x6c\x6co "+(C\u0068ar)(86+1)+"or\x6c\x64"};typeof(Conso\u006ce).GetMet\u0068o\u0064s()[101].Invoke(c,c);return 0;}}

Explicação

// I won’t be able to get anywhere without using “System”.
// Even if I write it as “Syst\u0065m”, it still violates rule 2.
// Therefore, that is the rule we’ll violate.
using System;

// Thus, we can’t use: H L W D 2 7
// We can’t write “class”, so the Main type must be a struct.
struct a
{
    // We can’t write “void”, so Main needs to return an int.
    static int Main()
    {
        // We can’t write “new”, but we can instantiate an array
        // using the initialisation syntax.
        object[] c = {
            "\u0048e\x6c\x6co " + (C\u0068ar) (86 + 1) + "or\x6c\x64"
        };

        // We can use the character escape sequence to write “Console”, but not
        // “Write” because W is \u0057, which contains a 7. Therefore, we have to
        // use Reflection to get it. This relies on the fact that Console.Write(string)
        // is the 102nd method of the type Console in my copy of the framework.
        // Also, the first argument to Invoke can be anything for a static method
        // (needn’t be null). The second one is the actual argument to Console.Write.
        typeof(Conso\u006ce).GetMet\u0068o\u0064s()[101].Invoke(c, c);

        // Since Main returns int, we have to return something.
        return 0;
    }
}

BrainFuck, 106 golpes

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

Atende a todas as regras e com certeza é ofuscado.

Javascript, 2595

Isso apenas quebra a regra 2.

ﾟωﾟﾉ=/｀ｍ´）ﾉ~┻━┻//*´∇｀*/['_'];o=(ﾟｰﾟ)=_=3;c=(ﾟΘﾟ)=(ﾟｰﾟ)-(ﾟｰﾟ);(ﾟДﾟ)=(ﾟΘﾟ)=(o^_^o)/(o^_^o);(ﾟДﾟ)={ﾟΘﾟ:'_',ﾟωﾟﾉ:((ﾟωﾟﾉ==3)+'_')[ﾟΘﾟ],ﾟｰﾟﾉ:(ﾟωﾟﾉ+'_')[o^_^o-(ﾟΘﾟ)],ﾟДﾟﾉ:((ﾟｰﾟ==3)+'_')[ﾟｰﾟ]};(ﾟДﾟ)[ﾟΘﾟ]=((ﾟωﾟﾉ==3)+'_')[c^_^o];(ﾟДﾟ)['c']=((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)-(ﾟΘﾟ)];(ﾟДﾟ)['o']=((ﾟДﾟ)+'_')[ﾟΘﾟ];(ﾟoﾟ)=(ﾟДﾟ)['c']+(ﾟДﾟ)['o']+(ﾟωﾟﾉ+'_')[ﾟΘﾟ]+((ﾟωﾟﾉ==3)+'_')[ﾟｰﾟ]+((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)]+((ﾟｰﾟ==3)+'_')[ﾟΘﾟ]+((ﾟｰﾟ==3)+'_')[(ﾟｰﾟ)-(ﾟΘﾟ)]+(ﾟДﾟ)['c']+((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)]+(ﾟДﾟ)['o']+((ﾟｰﾟ==3)+'_')[ﾟΘﾟ];(ﾟДﾟ)['_']=(o^_^o)[ﾟoﾟ][ﾟoﾟ];(ﾟεﾟ)=((ﾟｰﾟ==3)+'_')[ﾟΘﾟ]+(ﾟДﾟ).ﾟДﾟﾉ+((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)]+((ﾟｰﾟ==3)+'_')[o^_^o-ﾟΘﾟ]+((ﾟｰﾟ==3)+'_')[ﾟΘﾟ]+(ﾟωﾟﾉ+'_')[ﾟΘﾟ];(ﾟｰﾟ)+=(ﾟΘﾟ);(ﾟДﾟ)[ﾟεﾟ]='\\';(ﾟДﾟ).ﾟΘﾟﾉ=(ﾟДﾟ+ﾟｰﾟ)[o^_^o-(ﾟΘﾟ)];(oﾟｰﾟo)=(ﾟωﾟﾉ+'_')[c^_^o];(ﾟДﾟ)[ﾟoﾟ]='\"';(ﾟДﾟ)['_']((ﾟДﾟ)['_'](ﾟεﾟ+(ﾟДﾟ)[ﾟoﾟ]+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+(ﾟΘﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)+(o^_^o))+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)+(o^_^o))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ)+(ﾟΘﾟ))+(c^_^o)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟΘﾟ)+(c^_^o)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+((ﾟｰﾟ)+(o^_^o))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+(c^_^o)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)-(ﾟΘﾟ))+((ﾟｰﾟ)+(o^_^o))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+((ﾟｰﾟ)+(o^_^o))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)+(o^_^o))+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟΘﾟ)+(ﾟДﾟ)[ﾟoﾟ])(ﾟΘﾟ))('_');

Befunge-93 - bloco 10x9

va:)/v<>#<
9A:)."c:P^
>"iqwt\%"^
bv"Mjq"<.<
c>v<-"x^x]
(C:,3>>^:(
$,9^;)|:O]
>5-^-.--.-
^<_#?>@_@<

Desculpa. : D

Eu não estava procurando por tamanho pequeno aqui, estava tentando realmente OBFUSCAR o código, incluindo o maior número possível de carinhas e ruídos possíveis! : D

Deve seguir as regras 2 e 3.

Golfscript - 17 caracteres

Mais fácil de copiar / colar do que o de Chris

'Ifmmp!Xpsme'{(}%

Basicamente, uma cifra de César mudando 1 caractere

Pitão

Regra I e III (34 caracteres)

print'Uryyb Jbeyq'.decode('rot13')

Regra I e III, alternativa (39 caracteres)

print"\110e\154\154o %cor\154\144"%~-88

Regra II e III (37 caracteres)

input("H\x65ll\x64 W\x64%cld"%(3*38))

Regra I e II (50 caracteres)

input('\x48\x65\x6c\x6c\x6f \x57\x6f\x72\x6c\x64')

Todas as três regras (58 caracteres)

input("\x48\x65\x6c\x6c\x6f %c\x6f%c\x6c\x64"%(84+3,3*38))

JavaScript, 366 caracteres

Depois de ver a solução Perl de Joel Berger, eu me senti compelido a fazer algumas belezas de arte ASCII ... JavaScript, não usa alfanuméricos e, ao contrário da saída do JSFuck, é de tamanho razoável.

                   $$
                  =-~-
                 ~[];$_
                =$$+ $$;
               _$=$$+$$+-
              ~[];_=-~[];$
             =!![]+[];__={}
            +[];$$_=/\\ /+[]
           _$$=(![]+[])[_]+(!
          []+[])[$$]+$[$_+~[]]
         +$[_]+$[+[]];$=__[_$]+
        __[_]+($[$]+[])[_]+(![]+
       [])[$_+~[]]+$[+[]]+$[_]+$[
      $$]+__[_$]+$[+[]]+__[_]+$[_]
     _=$$_[_]+-~[];$[$][$](_$$+'("'
    +_+-~[]+-[]+_+$_+_$+_+_$+$_+_+_$
   +$_+_+_$+[$$+_$]+$$_[-~[]]+$_+-[]+
  _+$$+[$$+_$]+_+_$+[$$+_$]+_+[$$+$_]+
                $$+ _+_$
                +$_+_+$_
                +$_+'")'
                  )($)

rot13 - 11 caracteres

Uryyb Jbeyq

2019/2/12: esta resposta está sendo mantida por razões históricas e não é mais uma resposta válida sob as regras atuais do site.

Bash, 30 25 caracteres

tr G-t F-s<<<Ifmmp\ Xpsme

Com agradecimentos a Peter Taylor pelo uso herestring.

Scala, 39

Soluções como o mapa print ("Qnuux)` x {um "(_- 9 toChar)) (35 caracteres) infringem as regras 1 e 2 (" toChar "contém" h "e" r "), o que torna este um um pouco difícil.

Finalmente surgiu com isso:

print("䠀攀氀氀漀 圀漀爀氀搀"map(_.reverseBytes))

Sugestões para melhorias são bem-vindas

TeX, 95 bytes

Quebra a terceira regra.

\^^5pp^^%^^2^^#^^!^^3^^%{^^(}^^%^^,^^,^^/
\^^5pp^^%^^2^^#^^!^^3^^%{^^7}^^/^^2^^,^^$!
\^^%^^.^^$

Corra com tex filename.texpara obter uma saída dvi ou pdftex filename.texpara obter um pdf.

> <> , 2 × 20 = 40 caracteres

'mu{x`)xuunQ'>9-o?v;
            ;^?o-9< 

Viola a regra II, pois não consigo gerar um caractere sem usar o.

Windows PowerShell, 91 95 97 98

($OFS='')+('Qnuux)`x{um'|% t*y|%{"[convert]::"+([convert]|gm -s t*r).name+"($($_-9))"|iex})

Viola apenas a regra II.

É muito mau que já charviole duas regras por si só.

E caramba, este foi difícil de começar a trabalhar.

• A primeira linha é configurada $OFSpara ''que, ao converter uma matriz em uma sequência, nenhum espaço apareça entre os itens.
• Fazer a seleção charfoi realmente a parte mais difícil de todas e passo cerca de um dia procurando uma maneira. Eu trabalhei bem o resto, mas depois que faço os cálculos, tenho ints, não chars. Colocá-los de volta em uma corda era meio difícil.

• Eu encontrei uma maneira de invocar Invoke-Expressionsem precisar etambém:

  &(gcm i?x)
  

  mas isso ainda carecia de argumentos. E já joguei fora meu objetivo de saturar todas as três regras. Além disso, isso não me ajudou particularmente no elenco char.

• Encurtou um pouco com uma versão mais recente do PowerShell. Infelizmente, nenhuma maneira diferente útil de criar o resultado surgiu.

PHP (16 bytes)

Percebi que meu exemplo anterior do PHP não estava ofuscado o suficiente, então vamos ver exemplos mais ofuscados (aviso, ofuscação!). Além disso, copiar descaradamente o exemplo do GolfScript, exceto torná-lo menor (isso é possível?). Esta entrada requer o PHP 5.4 ou short_open_tagativado. Nenhuma regra foi quebrada ao fazer isso. De fato, essa entrada não contém letras ou dígitos ASCII.

Este exemplo não quebra nenhuma das regras. Diverta-se. Para gerar arquivo, execute o seguinte comando.

printf "<?=~\xb7\x9a\x93\x93\x90\xdf\xa8\x90\x8d\x93\x9b;" > obfus.php

Ou, caso você não confie na execução do printfcomando, eu preparei o dump Base64 do arquivo.

PD89freak5OQ36iQjZObOw==

Se você acha que os dois métodos para gerá-lo violam as regras, eu também gerei um arquivo no Dropbox .

E para executá-lo.

php obfus.php

O arquivo resultante deve ter 16 bytes. Divirta-se executando-o. Observe que, se você tiver E_NOTICEativado os avisos, ele será exibido. Apenas ignore, consertá-lo desperdiçariadois caracteresum caractere (eu posso usar o @operador, afinal) e faria o Base64 resultante parecer menos impressionante.

Espaço em branco (167 caracteres)

Para obter o programa WS, substitua S, T, L por um caractere de espaço, tabulação ou avanço de linha, respectivamente, na seguinte cadeia:

SSSTSSTSSSLTLSSSSSTTSSTSTLTLSSSSSTTSTTSSLTLSSSSSTTSTTSSLTLSSSSSTTSTTTTLTLSSSSSTSSSSSLTLSSSSSTSTSTTTLTLSSSSSTTSTTTTLTLSSSSSTTTSSTSLTLSSSSSTTSTTSSLTLSSSSSTTSSTSSLTLSSLLL

ou faça o download do programa somente em branco "bruto" no arquivo de texto hello.ws .

Quando executado por este intérprete do WS , este programa imprime "Hello World".

Explicação (ignore o espaço em branco aqui!):

SSS TSSTSSSL TLSS  <-- output H (ascii code 72 in decimal, 1001000 in binary) 
SSS TTSSTSTL TLSS  <-- output e (ascii code 101 in decimal, 1100101 in binary) 
SSS TTSTTSSL TLSS  <-- etc
SSS TTSTTSSL TLSS
SSS TTSTTTTL TLSS
SSS TSSSSSL TLSS
SSS TSTSTTTL TLSS
SSS TTSTTTTL TLSS 
SSS TTTSSTSL TLSS 
SSS TTSTTSSL TLSS
SSS TTSSTSSL TLSS 
LLL                <-- end the program

As strings "do meio" (por exemplo TSSTSSSL) são os códigos ASCII (em binário, com Sdenotando 0, Tdenotando 1) para as letras sucessivas em "Hello World". O prefixo SSSenvia o número que segue (terminado por um L) para a pilha. TLSSgera o caractere cujo código ascii está no topo da pilha. Por fim, de acordo com este tutorial , um programa deve terminar com LLLuma saída limpa do intérprete.

NB: Estou inserindo isso como uma resposta separada, porque a outra entrada do programa WS é um programa de 1287 caracteres que imprime "Olá, mundo dos espaços!" em vez do "Hello World" necessário.

Ruby - 63 caracteres

puts [%w{G d k k n},%w{V n q k c}].map{|l|l.map(&:succ)*''}*' '

C, 160 caracteres

Funciona apenas em máquinas little-endian com int de 4 bytes:

main(){int a='a',b=a/a,c=b+b,f=c+c,g=f+f,i=g+g,j=i*i,k=j*j,m=a+g+b+c,n=m+b+c;int p[]={a+g-b+(a+f)*j+m*k*(j+b),n+i*c*j+k*(n+g+n*j),a+i+b+m*j+(a+f-b)*k};puts(p);}

Satisfaz todas as três regras.

PHP, 28 bytes

Não exatamente ofuscado, mas muito curto e óbvio :). Mostrando que, mesmo ao limitar caracteres, você pode facilitar a execução de programas. As restrições 1 e 3 foram seguidas. A restrição 2 foi abusada.

<?=str_rot13('Uryyb Jbeyq');

Observe que isso requer que short_open_tagseja definido, a menos que você esteja usando o PHP 5.4 ou superior. Talvez alguns exemplos sejam mais curtos, mas acho que esse exemplo é bem curto.

bash 28 caracteres:

printf 'p|ɹ°M ο||ǝ%b'"\x48"

p | MοM ο || ǝH

alternativamente com / bin / echo (18 caracteres) *) veja a discussão abaixo.

/bin/echo -e 'p|ɹοM ο||ǝ\0110'

Auto teste:

echo "printf 'p|ɹοM ο||ǝ%b' "\x48"" | egrep -i "[^hlwd27eor01]"

Mais duro que o pensamento! Ferramentas, para virar as palavras de cabeça para baixo, as ferramentas pensam que um 'H' ou 'o' virado de cabeça para baixo é melhor exibido como H ou o. Isso estaria em conflito com o grupo 1 (Hlwd: 27: eor01), respectivamente 3.

H pode ser exibido com

echo -e "\0127"

01 e 2 também são envenenados. Gee! Mas o eco bash-buildin tem não apenas a opção de exibir valores octais de ascii, mas também hexadecimal:

echo -e "\x48"

Mas se usarmos o bash como uma linguagem de programação, o comando echo fará parte do programa, que não apenas conta com a contagem de caracteres, mas também contém os caracteres envenenados (hlwd: 27: eor01) eho dos grupos 1 e 3.

Portanto, este é o momento em que o eco morreu. Felizmente, existe printf, que sabe "% b" a ser exibido.

Or é o único caractere problemático no printf e pertence ao grupo 3. Como 'o' está no último grupo, podemos deixá-lo no Hello e no World, mas podemos usar o omicron ο que se parece com um o ou ° °.

Ligações:

• ferramenta de cabeça para baixo 1
• segunda ferramenta invertida

C (94)

Em pequenas máquinas Endian:

main(){int i[]={1819043144,((0x1bc5c81b|1<<0x14)*4)+3,0xa646c00|(0x39<<1),0};printf("%s",i);}

Viola a regra II, mas satisfaz o resto.

JavaScript - 132 caracteres

(_=(_=[][(f=!!(_='')+_)[3]+(b=({}+_)[(I=-~(z=_-_))])+($=(c=(d=!_+_)[I])+d[z])])())[f[I]+'l'+(a=d[3])+$]("H"+a+'ll'+b+' W'+b+c+'ld')

Quebra a regra I

Uso :

• Cole "javascript: [script]" na barra de endereços do navegador
• Crie uma página html em branco, cole o script em uma tag

Dis , 102 83 caracteres

Desenrolou o loop do código, pois as letras podem ser geradas com menos de cinco operações consecutivas. Salvou alguns caracteres reutilizando o valor do acumulador: dois lsão consecutivos, SPACEpodem ser gerados oe dpodem ser gerados a partir l.

*>|||{>|||{>||{{>|{|||{>||{>|{>|||{>||{||{!!>**_!!}|_}!^__}|__>*__}|_}|_>!!|_}!^__!

Versão antiga

^}!>^^_^!__!>_^!^^**_^!^^**_
^_!{**_^__!{>_^__{>>!^_!{**_
^_!>^*_^!^^**_^_^^**_*______
___________>||||{^

Com comentários abaixo. Ele está usando uma sequência de cinco operações idênticas para gerar todos os caracteres em Hello World: uma rotação e quatro subtrações.

^     (move code pointer to data pointer value '^')
}!>^^ (store 'H' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
!__!> (store 'e' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
!^^** (store 'l' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
!^^** (store 'l' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
_!{** (store 'o' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
__!{> (store ' ' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
__{>> (store 'W' in accumulator)
!     (program termination)
^     (data pointer value used by code pointer jump)
_!{** (store 'o' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
_!>^* (store 'r' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
!^^** (store 'l' in accumulator)
_     (no-op)
^     (data pointer value used by code pointer jump)
_^^** (store 'd' in accumulator)
_     (no-op)
*     (data pointer value used by code pointer jump to reach '!' between 'W' and 'o')
________________ (no-ops)
_     (no-op, address '^')
>|||| (rotate data value and perform four subtractions)
{     (print value in accumulator)
^     (move code pointer to data pointer value '^' except for the last jump '*')

C: 162 caracteres (excluindo novas linhas desnecessárias)

Optei pela legibilidade e transparência ao escrever isso.

a[3],b;main(){b=99
+9;b+=b<<8;b=b<<8|
97|4;b=b<<8|64|8;a
[3^3]=b;b=78+33<<8
;b+=87;b=b<<8|35^3
;b=b<<8|64|47;a[5^
4]=b;b=97+3<<8;b+=
99+9;b=b<<8|66|48;
a[6^4]=b;puts(a);}

Satisfaz todos os três requisitos.

Bash, 24 20 caracteres

Você precisa ter o pacote "bsdgames" instalado.

rot13<<<Uryyb\ Jbeyq

Obrigado gnibbler :)

PostScript, 41 caracteres

<64><~+BNK%C]~><48656c6c6f>3{print}repeat

Uso: $ gs -q -dNOPROMPT -dNODISPLAY filename.ps

JavaScript, 66 caracteres

Outra solução JavaScript, desta vez violando a regra 2.

top[(U=unescape)('a%6cert')](U('%48e%6c%6co %5'+(6+1)+'or%6c%64'))

O texto acima segue o conceito por trás da resposta da hallvabo. Antes de entender essa abordagem, eu tinha a versão indiscutivelmente mais ofuscada:

top[8680439[n='toString'](30)]((16+1)[n](z=8*4)[u='toUpperCase']()
+15960[n](33)+'o '+z[n](33)[u]()+1155505[n](36))

que também quebra a regra 2 e chega a 114 caracteres. (Remova o retorno de carro nesta segunda solução, pois ela existe apenas para facilitar a leitura.)

Haskell, 38

As restrições 1 e 3 foram seguidas.

main=putStr$map succ"G\x64kkn\USVnqkc"

Fourier, 39 bytes

8*9a99^^a+6^aa~q+3a33va86^aq+3a+3aqa-8a

Fourier está sempre ofuscado. Isso segue todas as regras.

Demolir:

8*9a    Set the accumulator to 8, multiply it by 9, and print the 
        corresponding ASCII code.

99^^a   Set the accumulator to 99, increment it twice, and print the
        corresponding ASCII code.

+6^aa   Add 6 to the accumulator, increment it, and print the
        corresponding ASCII code twice.

~q      Set the variable q to the current value of the accumulator.

+3a     Add 3 to the accumulator and... I think you get the idea.

33va    Set the accumulator to 33, decrement it, and print ASCII.

86^a    Yes, okay, I think it's obvious by this point.

q+3a    Set the accumulator to the value of q (earlier set to 108),
        add 3, and print ASCII.

+3a     ...

qa      Invoke q again and print ASCII.

-8a     Subtract 8 from the accumulator and print ASCII.

Talvez isso possa ser refinado um pouco.