Olá, mundo ofuscado

123

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

Kevin Brown
fonte
6
Eu acho que importem python não é permitido.
Alexandru
26
Essas regras também se aplicam às palavras-chave do idioma?
Hallvabo
8
essas restrições não diferenciam maiúsculas de minúsculas?
Enone
20
Alguém poderia explicar por que 2 e 7 não são permitidos? Estou curioso, pois não vejo por que foram escolhidos em particular.
Thomas Eding
4
@trinithis, e outros, de caracteres ASCII 72é "H"o que é por isso que eu escolhi esses dois
Kevin Brown

Respostas:

51

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                                                |%|
Chris Jester-Young
fonte
1
Embora eu queira pensar que é uma solução óbvia, se você não sabe ao certo como essa entrada funciona, você pode ler este spoiler: chat.stackexchange.com/transcript/message/442257#442257 :-)
Chris Jester -Julho 01/02
12
Não é ISO-8859-1, na verdade é Windows-1252.
precisa saber é o seguinte
@ GlitchMr: Na verdade, tenho certeza de que o envio também contém caracteres que estão fora do Windows-1252. ;-)
Chris Jester-Young
@xfix Realmente também não é o Windows-1252. Embora o Windows-1252 tenha caracteres mais válidos que o ISO-8859-1, minha entrada contém caracteres, como 0x8D e 0x90, que também não são válidos no Windows-1252.
Chris Jester-Young
É justo, esqueci que alguns caracteres são proibidos no Windows-1252.
22915 Konrad Borowski
171

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

Joel Berger
fonte
1
Eu tentei e é ótimo! +1
Tomas
2
@TomasT. obrigado, foi divertido de fazer, e na verdade demorou um pouco de golfe para conseguir isso em apenas 3 fotos!
Joel Berger
1
Para sua informação, usa o recurso Perl regexp (?{ code })para avaliar o código Perl personalizado enquanto faz a correspondência regexp. O código Perl personalizado imprime a mensagem. É legal porque não viola nenhuma das regras.
pts
5
Você senhor, é o olá rei do mundo!
recursion.ninja
1
Uau! Apenas Uau! Agora eu preciso aprender Perl apenas para ver como você fez isso.
Gryphon
69

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 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;
    }
}
Timwi
fonte
Você pode usar em Urivez de objectpara b. Você pode usar \xHHem strings, em vez de \u00HHonde é inequívoco ( \xé de tamanho variável). Pensando bem, você não precisa de bnada e pode apenas reutilizá-lo ccomo o primeiro argumento Invoke. O MSDN afirma que, para métodos estáticos, o primeiro argumento é ignorado. Isso reduz para 175 para mim.
Joey #
@ Joey: Uau, obrigado! Embora se o primeiro argumento para Invokepode ser qualquer coisa, ele não precisa mesmo ser c, poderia ser 0... :)
Timwi
Sim, reparou que quando eu tentei para inline c(que infelizmente não funciona desde que newrequer uma ee .Split('x')é muito longo (saiu em 177).
Joey
Eu não tinha ideia de que isso era possível. 1
Igby Largeman
1
Coisa muito inteligente que você fez GetMethods. +1
Soham Chowdhury
51

BrainFuck, 106 golpes

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

Atende a todas as regras e com certeza é ofuscado.

R. Martinho Fernandes
fonte
2
Acho que ainda posso jogar um pouco, mas isso terá que esperar até eu dormir um pouco.
R. Martinho Fernandes
34
BrainFuck não é ofuscado por sua definição?
Mbx
18
Qualquer programador BF competente seria capaz de reconhecer isso ...
Mehrdad
Isso quebra as regras 1 e 2: D
Thomas Eding
8
Brah, protegido pela comunidade , qualquer que seja, ++++++++++[>++++++>+++<<-]>++++++++++++.---.+++++++..+++.>++.<++++++++.--------.+++.------.--------.é apenas a 100 tacadas, o meu é melhor que o seu
OverCoder
44

Javascript, 2595

Isso apenas quebra a regra 2.

゚ω゚ノ=/`m´)ノ~┻━┻//*´∇`*/['_'];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゚])(゚Θ゚))('_');
Peter Olson
fonte
13
Eu tentei no UglifyJS, mas ele salvou -2574 bytes.
precisa saber é o seguinte
12
Não tenho ideia do que estou vendo aqui.
Bob
6
@Bob = Javascript ofuscado. Dica: começa atribuindo uma expressão regular literal (ou seja, '/ ` m´) ノ ~ ┻━┻ /') a uma variável com o nome `゚ ω ゚ ノ. That's followed by a comment and the expression ['_']` no contexto vazio. Em seguida, a variável o(junto com _e (゚ー゚)) recebe o valor 3. Ela continua nesse sentido, realizando muito trabalho inofensivo que não é efetivamente operacional e usando maneiras indiretas de realizar o trabalho pretendido (chamando alert("Hello world")) de maneira não óbvia. moda.
Mark Reed
40

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.

Aurel Bílý
fonte
18
"@_@" Eu ri.
Wug
35

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

mordedor
fonte
4
+1 Agradável por ser mais simples de copiar. A mina tem a vantagem de não infringir nenhuma das regras e também (provavelmente, dependendo se os caracteres de alto bit contam como símbolos) também cumprir o símbolo de golfe. :-)
Chris Jester-Young
Como isso quebra uma regra?
precisa
11
@sims, ele tem um enele
gnibbler
2
DOIS dos três. : D
Rob
30

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))
hallvabo
fonte
1
excluiu minha resposta, acho que a sua é mais abrangente.
st0le
+ 1, grande peça, mas nenhuma surpresa eu vi você jogar golfe :-)
Quixotic
Você precisa import codecsantes que possacodecs.decode
cat
Você pode remover os parênteses na primeira solução
Cyoce 17/10/16
23

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.

                   $$
                  =-~-
                 ~[];$_
                =$$+ $$;
               _$=$$+$$+-
              ~[];_=-~[];$
             =!![]+[];__={}
            +[];$$_=/\\ /+[]
           _$$=(![]+[])[_]+(!
          []+[])[$$]+$[$_+~[]]
         +$[_]+$[+[]];$=__[_$]+
        __[_]+($[$]+[])[_]+(![]+
       [])[$_+~[]]+$[+[]]+$[_]+$[
      $$]+__[_$]+$[+[]]+__[_]+$[_]
     _=$$_[_]+-~[];$[$][$](_$$+'("'
    +_+-~[]+-[]+_+$_+_$+_+_$+$_+_+_$
   +$_+_+_$+[$$+_$]+$$_[-~[]]+$_+-[]+
  _+$$+[$$+_$]+_+_$+[$$+_$]+_+[$$+$_]+
                $$+ _+_$
                +$_+_+$_
                +$_+'")'
                  )($)
FireFly
fonte
você poderia exibir o número de caracteres no seu código no cabeçalho? Estou curioso para ver quantos você consegui-lo para ...
Wally West
@ Eliseod'Annunzio lá vai, eu esqueci que isso era código de golfe. O comprimento é fornecido com o espaço em branco removido e o último ($)transformado em ()(porque eu adicionei $para simetria).
FireFly
Obrigado por suas dicas ... Eu tinha que redimensionar o meu código para conta para o "W" e, em seguida, encolheu-lo usando o seu conselho ...
Wally West
21

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.

mordedor
fonte
3
Rot13 é um idioma? : /
Santosh Kumar
3
sim e posso criar seu intérprete: P
oddcoder 14/03
6
Tecnicamente, rot13 é apenas uma cifra . É tanto um idioma quanto uma cifra de Vigenère.
XiKuuKy
19

Bash, 30 25 caracteres

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

Com agradecimentos a Peter Taylor pelo uso herestring.

Anon.
fonte
2
Você pode salvar 5 caracteres usando uma string aqui:tr G-t F-s<<<Ifmmp\ Xpsme
Peter Taylor
18

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

Luigi Plinge
fonte
18

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.

Bruno Le Floch
fonte
1
Uau, nunca soube que o TeX pode ser tão ofuscado!
gar
14

> <> , 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.

Joey
fonte
11

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.

Joey
fonte
Ainda há muitos "o" e "e" s aqui e um "r". Mas não tenho certeza se eu teria muito mais sorte em limpar isso. Ainda pode ter que tentar em algum momento.
Iszi
Basta ler novamente as regras - apenas dois dos três conjuntos de regras foram necessários e isso se qualifica. Bom show! Seria super incrível se pudéssemos criar um que leva 3/3, mas duvido que seja muito possível.
Iszi
Levei muito tempo para chegar a esse ponto e ainda duvido que seja possível seguir todas as regras.
Joey
10

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.

Konrad Borowski
fonte
9

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.

res
fonte
8

Ruby - 63 caracteres

puts [%w{G d k k n},%w{V n q k c}].map{|l|l.map(&:succ)*''}*' '
Nemo157
fonte
quebra # 1, embora
John Dvorak
E ainda mais curto: puts "Gdkkn~Vnqkc".split("").map(&:succ)*''- 43
Biketire 07/07
7

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.

grep
fonte
1
Você pode usar constantes numéricas sem 0,1,2,7: p[];main(){p={(5*5*5*5*5*64+96696)*(443+5688),(5*3*4*3+4-3)*(66*45*6-6*6-4+3)*8‌​3*(3+4),6544494+36868};puts(p);}- 111 caracteres.
1
Veia semelhante (na verdade, abordou o problema de algumas maneiras diferentes antes de decidir sobre isso). x[]={45483*39994-3958,48465*38543-5584,6584695-3333};main(){puts(x);}- 69 caracteres. Tenho certeza de que poderia economizar um pouco mais, dando mais tempo para matemáticos os literais. Foi uma forma divertida de passar algumas horas, de qualquer maneira :)
Cole Cameron
7

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.

Konrad Borowski
fonte
7

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 ° &deg;.

Ligações:

Usuário desconhecido
fonte
Voto positivo, mas sua reputação é muito ruim.
precisa saber é o seguinte
@ GlitchMr: Agora você pode - votei em algo a menos e deve ser confiscado 500N. :)
usuário desconhecido
dl.dropbox.com/u/63913412/stilltooleet.png . Além disso, as perguntas com voto negativo não diminuem a reputação. Respostas negativas, no entanto.
Konrad Borowski
@ GlitchMr: Ah, é isso! :)
usuário desconhecido
6

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.

Hoa Long Tam
fonte
6

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
m0sa
fonte
Quebra as regras 1 e 2. Você está usando o número 1 para as matrizes.
Kevin Brown
Você pode substituir 1por !![]+![]e 0por ""-""que não quebrar a regra # 2.
21411 HoLyVieR
Obrigado @ Bass5098 e @HoLyVieR, eu meio que perdi o 1 e o 0 ao minimizar o script. I substituídos com 0 z = _-_ e uma com I = - ~ z, I pode também usar ++ z, mas - ~ parece mais agradável :)
m0sa
3
Hã? !![]+![]? Por que não apenas 4-3?
Timwi
4
@Timwi: Mais ofuscação
Thomas Eding
6

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 '*')
Mark Jayxcela
fonte
6

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.

Para s
fonte
1
Gosto disso, mas infelizmente não atende a todas as regras, pois contém o dígito 7, violando a regra nº 3. Mas seria fácil se livrar 7. Além disso, adicionando alguns se int, adicionando alguns parênteses extras e adicionando int puts(int*);ao início, ele é compilado gcc -ansi -W -Wallapenas com um único aviso: o controle atinge o final da função não nula .
pts
5

Bash, 24 20 caracteres

Você precisa ter o pacote "bsdgames" instalado.

rot13<<<Uryyb\ Jbeyq

Obrigado gnibbler :)

PleaseStand
fonte
5

PostScript, 41 caracteres

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

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

KirarinSnow
fonte
1
você também pode executá-lo como:gsnd -q -- filename.ps
luser Droog
5

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

DocMax
fonte
4
Eu li que como R unescape.
Mateen Ulhaq 1/11/11
@MateenUlhaq Eu sempre leio como R unescape, e só toquei por um ano mais de uma década atrás ... O que há de errado comigo?
Mwr247
5

Haskell, 38

As restrições 1 e 3 foram seguidas.

main=putStr$map succ"G\x64kkn\USVnqkc"
Thomas Eding
fonte
4

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.

bkul
fonte
Woah, eu acabei de perceber que alguém usou Fourier: D Nice one, +1
Decay Beta