混淆的世界你好

123

创建显示文本“ Hello World”的最短混淆程序。

为了被视为混淆程序，它必须至少满足以下两个要求：

  • 不包含字符：h，l，w和d在任何情况下
  • 不包含字符：e，o，r，0，和1在任何情况下
  • 不包含以下字符：2或7

输入：
无

输出：
Hello World

code-golf  obfuscation  hello-world  restricted-source 
— 凯文·布朗
source
6
我猜import在python中是不允许的。
— Alexandru
26
这些规则也适用于语言关键字吗？
— hallvabo
8
这些不区分大小写的限制吗？
— oenone 2011年
20
有人可以解释为什么不允许使用2和7吗？我很好奇，因为我不明白为什么特别选择了这些。
— Thomas Eding
4
@trinithis和其他人，ASCII字符72就是"H"这就是为什么我选择了这两个字符的原因
— Kevin Brown

Answers:

51

GolfScript，17个字符

'·š”“ ??ߨ????” ›› {〜}％

测试此提交时，请将文件另存为纯二进制文件，而不是UTF-8。重新创建文件时遇到问题？这是它的十六进制转储：

00000000  27 b7 9a 93 93 90 df a8  90 8d 93 9b 27 7b 7e 7d  |'...........'{~}|
00000010  25                                                |%|
— 克里斯·杰斯特·杨
source
1
尽管我想这是一个显而易见的解决方案，但是如果您完全不清楚该条目的工作原理，则可以阅读以下破坏者：chat.stackexchange.com/transcript/message/442257#442257 :-)
— Chris Jester -Young 2011年
12
它不是ISO-8859-1，实际上是Windows-1252。
— Konrad Borowski
@GlitchMr：实际上，我可以肯定提交的内容也包含Windows-1252之外的字符。;-)
— 克里斯·杰斯特·杨
@xfix的确不是Windows-1252。尽管Windows-1252具有比ISO-8859-1更多的有效字符，但我的输入包含0x8D和0x90之类的字符，这些字符在Windows-1252中也无效。
— 克里斯·杰斯特·杨
公平地说，忘记了Windows-1252中不允许使用某些字符。
— Konrad Borowski
171

佩尔

由于显而易见的答案使用了某种形式的移动，因此我不得不使用Acme :: EyeDrops发布一些内容，但是我认为我的额外功能应该会更加有趣。

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

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

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

警告

从Perl 5.18版本开始，允许运行此代码的机制非常强大，默认情况下已禁用该机制以防止滥用。因此，在版本5.18+上，您可以将其添加use re 'eval';到脚本的顶部，或者，如果脚本被命名world.pl，则可以像那样运行它perl -Mre=eval world.pl。不幸的是，必须添加这些难看的字符，但请注意。（注意：我想强调的是，启用此功能时未使用某些库或插件，显示的代码是有效的Perl代码，默认情况下不再启用该机制）。

— 乔尔·伯格
source
1
我尝试过了，真是太好了！+1
— Tomas
2
@TomasT。谢谢，这样做很有趣，实际上确实需要打高尔夫球才能使它仅在3张照片中显示！
— 乔尔·伯杰
1
仅供参考，它使用Perl正则表达式功能(?{ code })在正则表达式匹配时评估自定义Perl代码。自定义Perl代码将打印消息。很好，因为它不违反任何规则。
— pts
5
先生，您好，世界国王！
— recursion.ninja
1
哇！哇！现在，我需要学习Perl，以了解您到底是如何做到的。
— 狮ry
69

C＃（175个字符）

在C＃中执行此操作是一个很大的挑战，因为这些限制使得无法使用很多常见的关键字。在C＃中，可以在标识符中使用\ uxxxx Unicode转义序列，但不幸的是，不能在关键字中使用。

我怀疑该解决方案仅在针对.NET 4.0编译时才有效。有关原因，请参见说明。

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;}}

说明

// 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
source
您可以使用Uri代替objectfor b。您可以\xHH在字符串中使用它，而不是\u00HH在明确的地方使用（\x长度可变）。经过深思熟虑，您根本不需要b，可以将其c作为第一个参数重用Invoke。MSDN指出，对于静态方法，第一个参数将被忽略。这对我来说降至175。
— 乔伊，
@Joey：哇，谢谢！尽管如果to的第一个参数Invoke可以是任何东西，它甚至不必是c，它可以是0... :)
— Timwi
是的，注意到当我尝试内联时c（可悲的是，由于new需要an e且.Split('x')时间太长（在177中退出），因此无法正常工作）
— Joey
我不知道这是可能的。+1
— Igby Largeman 2011年
1
您所做的事情非常聪明GetMethods。+1
— Soham Chowdhury
51

脑操106招

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

符合所有规则，并且确定已被混淆。

— R.马丁尼奥·费尔南德斯
source
2
我想我仍然可以打一点，但这必须等到我入睡。
— R. Martinho Fernandes
34
BrainFuck的定义不难理解吗？
— mbx
18
任何称职的BF程序员都将能够意识到这一点……
— Mehrdad
这打破了规则1和2：D
— 托马斯·爱丁
8
Brah，受社区保护，无论如何，++++++++++[>++++++>+++<<-]>++++++++++++.---.+++++++..+++.>++.<++++++++.--------.+++.------.--------.仅100招，我的胜过您的
— OverCoder 2015年
44

Javascript，2595年

这只会违反规则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ﾟ])(ﾟΘﾟ))('_');
— 彼得·奥尔森
source
13
我在UglifyJS上尝试过它，但是它节省了-2574字节。
— Konrad Borowski
12
我不知道我在这里看什么。
— 鲍勃
6
@Bob =模糊的Javascript。提示：首先. That's followed by a comment and the expression 在无效上下文中将正则表达式文字（即'/｀ ｍ´）´〜┻━┻/'分配给名称为ﾟωﾟ ﾉ['_']` 的变量。然后，变量o（与_和一起(ﾟｰﾟ)）被赋值为3。它沿这一方向继续，进行了很多无害的额外工作，这些工作实际上是无人操作的，并使用回旋方式以alert("Hello world")非显而易见的方式完成了预期的工作（调用）时尚。
— 马克·里德2014年
6
— Jason
40

Befunge-93-10x9块

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

抱歉。：D

我并不想在这里变小，我试图通过尽可能多地添加笑脸和噪音来真正混淆代码！：D

应该符合规则2和3。

— 奥雷尔·比利
source
18
“@_@“ 我笑了。
— 乌格2012年
35

Golfscript-17个字符

比Chris'更容易复制/粘贴

'Ifmmp!Xpsme'{(}%

基本上，凯撒密码移位1个字符

— ni
source
4
+1很容易复制。我的优点是不违反任何规则，并且（可能取决于高位字符是否视为符号）也可以实现符号高尔夫。:-)
— 克里斯·杰斯特·杨
这如何违反规则？
— d -_- b
11
@sims，它有e它
— gnibbler
2
三个中的两个。：D
— 罗布
30

蟒蛇

规则I和III（34个字符）

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

规则I和III，替代（39个字符）

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

规则II和III（37个字符）

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

规则I和II（50个字符）

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

所有三个规则（58个字符）

input("\x48\x65\x6c\x6c\x6f %c\x6f%c\x6c\x64"%(84+3,3*38))
— Hallvabo
source
1
删除了我的答案，我认为您的答案更全面。
— st0le 2011年
+1，很棒，但我没看过你打高尔夫球:-)
— Quixotic
您需要import codecs在您能codecs.decode
— 猫
您可以在第一个解决方案中删除的括号
— Cyoce
23

JavaScript，366个字符

看了Joel Berger的Perl解决方案之后，我感到自己不得不做一些ASCII艺术美化工作……JavaScript，不使用字母数字，并且与JSFuck输出相反，它的大小实际上是合理的。

                   $$
                  =-~-
                 ~[];$_
                =$$+ $$;
               _$=$$+$$+-
              ~[];_=-~[];$
             =!![]+[];__={}
            +[];$$_=/\\ /+[]
           _$$=(![]+[])[_]+(!
          []+[])[$$]+$[$_+~[]]
         +$[_]+$[+[]];$=__[_$]+
        __[_]+($[$]+[])[_]+(![]+
       [])[$_+~[]]+$[+[]]+$[_]+$[
      $$]+__[_$]+$[+[]]+__[_]+$[_]
     _=$$_[_]+-~[];$[$][$](_$$+'("'
    +_+-~[]+-[]+_+$_+_$+_+_$+$_+_+_$
   +$_+_+_$+[$$+_$]+$$_[-~[]]+$_+-[]+
  _+$$+[$$+_$]+_+_$+[$$+_$]+_+[$$+$_]+
                $$+ _+_$
                +$_+_+$_
                +$_+'")'
                  )($)
— 萤火虫
source
您能否在标题中显示代码中的字符数？我很想知道您
— 有多少钱
@ Eliseod'Annunzio你去了，我忘了这是代码高尔夫。长度以空格去除，最后一个($)变成()（因为我$为对称而添加）。
— FireFly 2014年
感谢您的提示...我不得不调整代码大小以考虑“ W”，然后使用您的建议将其缩小...
— WallyWest 2014年
21

rot13-11个字符

Uryyb Jbeyq

2019/2/12：由于历史原因，保留了此答案，根据当前站点规则，该答案不再有效。

— ni
source
3
rot13是语言吗？：/
— Santosh Kumar 2015年
3
是的，我可以创建其解释器：P
— 奇怪的编码器2016年
6
从技术上讲，rot13只是一个密码。它和Vigenère密码一样是一种语言。
— XiKuuKy
19

重击，30 25个字符

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

感谢Peter Taylor的herestring用法。

— 阿农
source
2
您可以使用此处字符串保存5个字符：tr G-t F-s<<<Ifmmp\ Xpsme
— Peter Taylor
18

斯卡拉39岁

像print（“ Qnuux）`x {um” map（_- 9 toChar））（35个字符）这样的解决方案会违反规则1和2（“ toChar”包含“ h”和“ r”），这使得有点硬。

终于想到了这个：

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

欢迎提出改进建议

— 路易吉·普林格（Luigi Plinge）
source
18

TeX，95字节

违反第三条规则。

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

运行tex filename.tex以获取dvi输出或pdftex filename.tex获取pdf。

— 布鲁诺·勒弗洛奇
source
1
哇，从来不知道TeX可以被如此迷惑！
— gar 2014年
14

> <>，2×20 = 40个字符

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

违反规则II，因为如果不使用，我将无法输出字符o。

— 乔伊
source
11

Windows PowerShell，91 95 97 98

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

仅违反规则II。

char本身已经违反了两个规则是非常邪恶的。

还有，这很难工作。

  • 第一行设置$OFS为''当将数组强制转换为字符串时，项目之间不会出现空格。
  • 投射到char实际上是最困难的部分，我花了整整一天的时间寻找一种方法。我让其余的一切工作都很好，但是一旦对它们进行计算，我就会得到ints而不是char。将它们放回字符串中有点困难。

  • 我也找到了一种Invoke-Expression不需要的调用方法e：

    &(gcm i?x)

    但这仍然缺乏论点。到那时我已经放弃了满足所有三个规则的目标。而且它并没有对我铸造出特殊的帮助char。

  • 使用更新的PowerShell版本稍微缩短了一点。可悲的是，没有一种有用的方法来产生结果。

— 乔伊
source
这里仍然有很多“ o”和“ e”，还有一个“ r”。不过，不确定我是否还有运气会更好。可能还需要在某个时候试一下。
— Iszi 2013年
只需重新阅读规则-只需满足三个规则集中的两个即可，这确实符合条件。不错的秀！如果我们能拿出3/3的像素，那将是超级好极了，但我怀疑这是否可能。
— Iszi 2013年
我已经花了很多时间达到这一点，但我仍然怀疑是否可以遵循所有规则。
— 乔伊，
10

PHP（16字节）

我注意到我以前的PHP示例还不够模糊，因此让我们来看更多明显混淆的示例（警告，混淆！）。另外，公然复制GolfScript示例，除了使其更小（甚至可以吗？）。此项需要PHP 5.4或short_open_tag启用。进行此操作时没有违反规则。实际上，该条目不包含任何ASCII字母或数字。

此示例不违反任何规则。玩得开心。要生成文件，请运行以下命令。

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

或者，如果您不信任运行printf命令，则我已经准备了该文件的Base64转储。

PD89freak5OQ36iQjZObOw==

如果您认为生成它的两种方法都违反了规则，那么我也在Dropbox上生成了文件。

并运行它。

php obfus.php

结果文件应具有16个字节。玩得开心。请注意，如果E_NOTICE启用了警告，它将显示通知。只是忽略它，修复它会浪费两个字符一个字符（@毕竟我可以使用运算符），并且会使生成的Base64看起来不那么出色。

— 康拉德·鲍罗夫斯基（Konrad Borowski）
source
9

空格（167个字符）

要获取WS程序，请在以下字符串中分别用空格，制表符或换行符替换S，T，L：

SSSTSSTSSSLTLSSSSSTTSSTSTLTLSSSSSTTSTTSSLTLSSSSSTTSTTSSLTLSSSSSTTSTTTTLTLSSSSSTSSSSSLTLSSSSSTSTSTTTLTLSSSSSTTSTTTTLTLSSSSSTTTSSTSLTLSSSSSTTSTTSSLTLSSSSSTTSSTSSLTLSSLLL

或在文本文件hello.ws中下载“仅限空白”程序。

当由此WS解释器执行时，此程序将打印“ Hello World”。

说明（此处忽略空格！）：

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

“中间”字符串（例如TSSTSSSL）是“ Hello World”中连续字母的ASCII码（二进制，S表示0，T表示1）。前缀SSS将其后的数字（以终止L）压入堆栈。TLSS输出ASCII代码位于堆栈顶部的字符。最后，根据本教程，程序必须以结束，LLL以使解释器干净退出。

注意：我输入这个是一个单独的答案，因为另一个WS程序条目是一个1287个字符的程序，其中显示“你好，世界的空间！”。而不是必需的“ Hello World”。

— 资源
source
8

Ruby-63个字符

puts [%w{G d k k n},%w{V n q k c}].map{|l|l.map(&:succ)*''}*' '
— 尼莫157
source
打破＃1，但是
— John Dvorak
甚至更短：puts "Gdkkn~Vnqkc".split("").map(&:succ)*''- 43
— Biketire
7

C，160个字符

仅在具有4字节int的little-endian机器上工作：

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);}

满足所有三个规则。

— grep
source
1
您可以只使用不带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个字符。
1
同样的道理（在解决此问题之前，实际上以几种不同的方式解决了该问题）。x[]={45483*39994-3958,48465*38543-5584,6584695-3333};main(){puts(x);}-69个字符。我敢肯定，如果给我更多的时间对字面量进行数学化处理，我可以节省更多。无论如何，这是一种花费几个小时的有趣方式：)
— 科尔·卡梅隆
7

PHP，28字节

没有完全混淆，但很短很明显:)。表明即使限制字符，您也可以很容易地遵循程序。约束1和3紧随其后。约束2被滥用。

<?=str_rot13('Uryyb Jbeyq');

请注意short_open_tag，除非您使用的是PHP 5.4或更高版本，否则需要进行设置。也许有些例子比较短，但是我认为这个例子很短。

— 康拉德·鲍罗夫斯基（Konrad Borowski）
source
7

bash 28个字符：

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

p |ɹοMο||ǝH

或者使用/ bin / echo（18个字符）*）参见下面的讨论。

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

自我测试： 

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

比思想更难！工具，用于将Word倒置，工具认为将“ H”或“ o”倒置时最好显示为H或o。这将分别与组1（Hlwd：27：eor01）3。

H可以显示为

echo -e "\0127"

但是01和2也中毒了。！但是bash-buildin echo不仅可以显示八进制ascii值，还可以显示十六进制：

echo -e "\x48"

但是，如果我们将bash用作编程语言，则echo命令是程序的一部分，它不仅会计入字符数，还会包含第1组和第3组的有毒字符（hlwd：27：eor01）eho。

所以这是回声消失的时刻。幸运的是，这里有printf，它知道可以显示“％b”。

r是printf中唯一有问题的字符，属于第3组。由于'o'在最后一组中，我们可以将其保留在Hello和World中，但是我们可以使用看起来像o 的omicronο ° &deg;。

链接：

— 用户未知
source
会对此表示支持，但是您的声誉太低落了。
— Konrad Borowski
@GlitchMr：现在您可以了-我投了反对票，应该被认为是500N。:)
— 未知用户
dl.dropbox.com/u/63913412/stilltooleet.png。同样，拒绝问题不会降低声誉。但是，拒绝投票确实可以。
— Konrad Borowski
@GlitchMr：就是这样！:)
— 用户未知
6

C（94）

在小型Endian机器上：

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

违反规则II，但满足其余条件。

— 华隆潭
source
6

JavaScript-132个字符

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

休息 治我

用法：

  • 将“ javascript：[脚本]”粘贴到浏览器地址栏中
  • 制作一个空白的html页面，将脚本粘贴到标签中
— m0sa
source
打破规则1和2。您将数字1用于数组。
— 凯文·布朗
您可以替换1通过!![]+![]，并0通过""-""以不破坏规则＃2。
— HolyVieR 2011年
感谢@ Bass5098和@HoLyVieR，在最小化脚本时，我有点想念1和0。我用z = _-_替换了0，用I =
— -〜z
3
?？!![]+![]？为什么不只是4-3呢？
— Timwi
4
@Timwi：更多的混淆
— 托马斯Eding
6

Dis，102 83个字符

由于可以用少于五个连续的操作生成字母，因此展开了代码循环。通过重用累加器值保存了几个字符：两个l是连续的，SPACE可以从生成o和d可以从生成l。

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

旧版本

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

下面有评论。它使用五个相同操作的序列来生成所有字符Hello World：一个旋转和四个减法。

^     (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 '*')
— 马克·贾克斯拉
source
6

C：162个字符（不包括不必要的换行符）

撰写本文时，我选择了可​​读性和透明性。

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);}

它满足所有三个要求。

— 福斯
source
1
我喜欢这样，但是很遗憾，它不满足所有规则，因为它包含数字7，违反了规则3。但是，摆脱它很容易7。同样，通过添加一些ints，并添加一些额外的括号并添加int puts(int*);到开头，它gcc -ansi -W -Wall仅通过一个警告进行编译：控制到达非void函数的结尾。
— pts
5

Bash，24岁 20个字符

您需要安装“ bsdgames”软件包。

rot13<<<Uryyb\ Jbeyq

谢谢g :)

— 请站
source
5

PostScript，41个字符

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

用法： $ gs -q -dNOPROMPT -dNODISPLAY filename.ps

— 基拉林·雪诺
source
1
您也可以像这样运行它：gsnd -q -- filename.ps
— luser droog
5

JavaScript，66个字符

另一个JavaScript解决方案，这次打破了规则2。

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

以上是hallvabo回答背后的概念。在继续使用这种方法之前，我有一个更加混乱的版本：

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

这也打破了规则2，并以114个字符出现。（在第二个解决方案中删除回车架，因为它只是为了便于阅读。）

— DocMax
source
4
我读为R unescape。
— Mateen Ulhaq
@MateenUlhaq我一直把它读为R unescape，十年前我才玩了一年……我怎么了？
— Mwr247
4

Fourier，39个字节

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

傅里叶总是令人困惑。这跟所有规则。

分解：

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.

也许可以稍微完善一下。

— bkul
source
哇，我刚刚才意识到有人在使用Fourier：D Nice，+ 1
— Beta Decay
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.